diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/.gitignore b/Quellcodes/Alg_DS_Baumalgorithmen/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/BaumTester.java b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/BaumTester.java new file mode 100644 index 0000000..8cc0446 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/BaumTester.java @@ -0,0 +1,2811 @@ +import static org.junit.Assert.*; +import org.junit.Test; + +/** + * Eine Testklasse für Baumalgorithmen + * + * @author Rainer Helfrich + * @version 02.11.2020 + */ +public class BaumTester +{ + @Test + public void test001() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(0)); + assertEquals(481,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(512)); + assertTrue(ba.enthaelt(596)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(510)); + assertFalse(ba.enthaelt(554)); + assertFalse(ba.enthaelt(287)); + assertFalse(ba.enthaelt(99)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(875)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(974)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(146)); + assertTrue(ba.enthaelt(366)); + assertTrue(ba.enthaelt(367)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(175)); + } + + @Test + public void test002() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(1)); + assertEquals(183,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(711)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(637)); + assertFalse(ba.enthaelt(888)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(692)); + assertTrue(ba.enthaelt(731)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(667)); + assertFalse(ba.enthaelt(549)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(825)); + assertTrue(ba.enthaelt(592)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(416)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(388)); + } + + @Test + public void test003() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(2)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(985)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(374)); + assertFalse(ba.enthaelt(304)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(67)); + assertFalse(ba.enthaelt(972)); + assertFalse(ba.enthaelt(384)); + assertFalse(ba.enthaelt(845)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(353)); + assertTrue(ba.enthaelt(656)); + assertTrue(ba.enthaelt(207)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(163)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(69)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(189)); + } + + @Test + public void test004() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(3)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(132)); + assertFalse(ba.enthaelt(921)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(395)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(141)); + assertTrue(ba.enthaelt(523)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(315)); + assertTrue(ba.enthaelt(849)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(666)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(76)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(585)); + } + + @Test + public void test005() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(4)); + assertEquals(133,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(13)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(236)); + assertFalse(ba.enthaelt(468)); + assertTrue(ba.enthaelt(428)); + assertFalse(ba.enthaelt(312)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(854)); + assertTrue(ba.enthaelt(657)); + assertTrue(ba.enthaelt(232)); + assertTrue(ba.enthaelt(659)); + assertTrue(ba.enthaelt(55)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(127)); + } + + @Test + public void test006() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(5)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(243)); + assertFalse(ba.enthaelt(248)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(285)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(187)); + assertTrue(ba.enthaelt(4)); + assertFalse(ba.enthaelt(497)); + assertTrue(ba.enthaelt(983)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(47)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(116)); + assertTrue(ba.enthaelt(287)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(165)); + assertTrue(ba.enthaelt(905)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(985)); + } + + @Test + public void test007() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(6)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(452)); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(849)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(610)); + assertFalse(ba.enthaelt(73)); + assertTrue(ba.enthaelt(472)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(704)); + assertTrue(ba.enthaelt(828)); + assertTrue(ba.enthaelt(178)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(341)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(916)); + assertTrue(ba.enthaelt(227)); + } + + @Test + public void test008() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(7)); + assertEquals(389,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(772)); + assertFalse(ba.enthaelt(426)); + assertFalse(ba.enthaelt(953)); + assertTrue(ba.enthaelt(319)); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(417)); + assertTrue(ba.enthaelt(883)); + assertTrue(ba.enthaelt(657)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(80)); + assertFalse(ba.enthaelt(183)); + assertFalse(ba.enthaelt(318)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(412)); + assertFalse(ba.enthaelt(145)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(572)); + assertTrue(ba.enthaelt(208)); + } + + @Test + public void test009() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(8)); + assertEquals(159,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(746)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(850)); + assertFalse(ba.enthaelt(267)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(1009)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(166)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(25)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(709)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(853)); + assertTrue(ba.enthaelt(628)); + assertTrue(ba.enthaelt(202)); + } + + @Test + public void test010() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(9)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(993)); + assertTrue(ba.enthaelt(904)); + assertFalse(ba.enthaelt(211)); + assertTrue(ba.enthaelt(845)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(544)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(852)); + assertFalse(ba.enthaelt(65)); + assertTrue(ba.enthaelt(805)); + assertTrue(ba.enthaelt(224)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(604)); + assertTrue(ba.enthaelt(273)); + assertTrue(ba.enthaelt(161)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(590)); + } + + @Test + public void test011() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(10)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(895)); + assertTrue(ba.enthaelt(344)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(181)); + assertFalse(ba.enthaelt(661)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(54)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(690)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(185)); + assertFalse(ba.enthaelt(657)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(907)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(348)); + } + + @Test + public void test012() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(11)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(42)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(650)); + assertTrue(ba.enthaelt(61)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(1013)); + assertFalse(ba.enthaelt(368)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(559)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(987)); + assertTrue(ba.enthaelt(582)); + assertTrue(ba.enthaelt(845)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(656)); + } + + @Test + public void test013() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(12)); + assertEquals(171,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(146)); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(114)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(51)); + assertFalse(ba.enthaelt(399)); + assertFalse(ba.enthaelt(43)); + assertTrue(ba.enthaelt(595)); + assertTrue(ba.enthaelt(831)); + assertFalse(ba.enthaelt(259)); + assertTrue(ba.enthaelt(960)); + assertTrue(ba.enthaelt(919)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(394)); + assertTrue(ba.enthaelt(466)); + assertTrue(ba.enthaelt(459)); + assertTrue(ba.enthaelt(539)); + } + + @Test + public void test014() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(13)); + assertEquals(135,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(870)); + assertFalse(ba.enthaelt(978)); + assertFalse(ba.enthaelt(871)); + assertFalse(ba.enthaelt(669)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(480)); + assertTrue(ba.enthaelt(449)); + assertFalse(ba.enthaelt(380)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(436)); + assertTrue(ba.enthaelt(120)); + assertTrue(ba.enthaelt(433)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(993)); + } + + @Test + public void test015() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(14)); + assertEquals(101,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(583)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(157)); + assertFalse(ba.enthaelt(170)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(458)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(727)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(155)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test016() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(15)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(796)); + assertFalse(ba.enthaelt(842)); + assertFalse(ba.enthaelt(853)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(736)); + assertFalse(ba.enthaelt(76)); + assertFalse(ba.enthaelt(325)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(483)); + assertTrue(ba.enthaelt(190)); + assertTrue(ba.enthaelt(590)); + assertTrue(ba.enthaelt(16)); + assertTrue(ba.enthaelt(534)); + assertTrue(ba.enthaelt(762)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(775)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(760)); + } + + @Test + public void test017() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(16)); + assertEquals(95,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(745)); + assertTrue(ba.enthaelt(293)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(180)); + assertFalse(ba.enthaelt(188)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(356)); + assertFalse(ba.enthaelt(973)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(54)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(520)); + assertTrue(ba.enthaelt(429)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(194)); + } + + @Test + public void test018() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(17)); + assertEquals(315,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(837)); + assertTrue(ba.enthaelt(543)); + assertFalse(ba.enthaelt(696)); + assertFalse(ba.enthaelt(307)); + assertTrue(ba.enthaelt(140)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(405)); + assertFalse(ba.enthaelt(178)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(418)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(997)); + assertTrue(ba.enthaelt(534)); + } + + @Test + public void test019() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(18)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(709)); + assertFalse(ba.enthaelt(22)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(892)); + assertFalse(ba.enthaelt(176)); + assertFalse(ba.enthaelt(680)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(198)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(917)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(98)); + assertTrue(ba.enthaelt(521)); + assertTrue(ba.enthaelt(586)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(197)); + } + + @Test + public void test020() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(19)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(471)); + assertFalse(ba.enthaelt(742)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(682)); + assertFalse(ba.enthaelt(336)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(895)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(495)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(853)); + } + + @Test + public void test021() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(20)); + assertEquals(279,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(439)); + assertTrue(ba.enthaelt(687)); + assertFalse(ba.enthaelt(216)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(516)); + assertTrue(ba.enthaelt(335)); + assertFalse(ba.enthaelt(703)); + assertTrue(ba.enthaelt(132)); + assertTrue(ba.enthaelt(630)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(606)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(422)); + assertFalse(ba.enthaelt(43)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(410)); + assertTrue(ba.enthaelt(235)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test022() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(21)); + assertEquals(215,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(310)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(474)); + assertFalse(ba.enthaelt(123)); + assertTrue(ba.enthaelt(824)); + assertFalse(ba.enthaelt(756)); + assertFalse(ba.enthaelt(829)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(755)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(662)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(195)); + assertTrue(ba.enthaelt(365)); + assertTrue(ba.enthaelt(889)); + } + + @Test + public void test023() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(22)); + assertEquals(107,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(821)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(884)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(545)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(435)); + assertFalse(ba.enthaelt(493)); + assertFalse(ba.enthaelt(823)); + assertFalse(ba.enthaelt(355)); + assertTrue(ba.enthaelt(276)); + assertTrue(ba.enthaelt(84)); + assertTrue(ba.enthaelt(265)); + assertTrue(ba.enthaelt(140)); + assertTrue(ba.enthaelt(529)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(724)); + assertTrue(ba.enthaelt(352)); + } + + @Test + public void test024() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(23)); + assertEquals(207,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(268)); + assertFalse(ba.enthaelt(332)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(666)); + assertTrue(ba.enthaelt(36)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(537)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(941)); + assertTrue(ba.enthaelt(665)); + assertTrue(ba.enthaelt(967)); + assertTrue(ba.enthaelt(667)); + assertTrue(ba.enthaelt(684)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(800)); + } + + @Test + public void test025() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(24)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(197)); + assertFalse(ba.enthaelt(983)); + assertFalse(ba.enthaelt(470)); + assertFalse(ba.enthaelt(487)); + assertTrue(ba.enthaelt(44)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(714)); + assertFalse(ba.enthaelt(623)); + assertTrue(ba.enthaelt(18)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(864)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(488)); + } + + @Test + public void test026() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(25)); + assertEquals(247,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(999)); + assertTrue(ba.enthaelt(173)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(892)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(919)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(4)); + assertFalse(ba.enthaelt(462)); + assertFalse(ba.enthaelt(877)); + assertFalse(ba.enthaelt(568)); + assertTrue(ba.enthaelt(834)); + assertTrue(ba.enthaelt(382)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(575)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(528)); + } + + @Test + public void test027() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(26)); + assertEquals(179,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(626)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(365)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(366)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(900)); + assertTrue(ba.enthaelt(496)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(391)); + assertFalse(ba.enthaelt(801)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(310)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(262)); + assertTrue(ba.enthaelt(513)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(403)); + } + + @Test + public void test028() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(27)); + assertEquals(209,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(627)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(364)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(173)); + assertFalse(ba.enthaelt(257)); + assertFalse(ba.enthaelt(277)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(896)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(706)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(480)); + assertTrue(ba.enthaelt(926)); + assertTrue(ba.enthaelt(832)); + assertTrue(ba.enthaelt(271)); + } + + @Test + public void test029() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(28)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(942)); + assertTrue(ba.enthaelt(924)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(528)); + assertFalse(ba.enthaelt(495)); + assertFalse(ba.enthaelt(262)); + assertFalse(ba.enthaelt(413)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(230)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(758)); + assertTrue(ba.enthaelt(91)); + assertTrue(ba.enthaelt(995)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(62)); + } + + @Test + public void test030() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(29)); + assertEquals(71,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(846)); + assertFalse(ba.enthaelt(828)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(456)); + assertFalse(ba.enthaelt(424)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(908)); + assertFalse(ba.enthaelt(200)); + assertFalse(ba.enthaelt(463)); + assertFalse(ba.enthaelt(246)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(553)); + assertTrue(ba.enthaelt(223)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(222)); + assertTrue(ba.enthaelt(806)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(10)); + } + + @Test + public void test031() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(30)); + assertEquals(109,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(154)); + assertFalse(ba.enthaelt(1000)); + assertTrue(ba.enthaelt(355)); + assertFalse(ba.enthaelt(960)); + assertFalse(ba.enthaelt(301)); + assertFalse(ba.enthaelt(94)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(440)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(71)); + assertFalse(ba.enthaelt(44)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(752)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(122)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(923)); + assertTrue(ba.enthaelt(689)); + } + + @Test + public void test032() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(31)); + assertEquals(87,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(866)); + assertTrue(ba.enthaelt(304)); + assertFalse(ba.enthaelt(623)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(761)); + assertTrue(ba.enthaelt(206)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(769)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(622)); + assertTrue(ba.enthaelt(61)); + assertTrue(ba.enthaelt(409)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(30)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(868)); + assertTrue(ba.enthaelt(36)); + } + + @Test + public void test033() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(32)); + assertEquals(521,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(211)); + assertFalse(ba.enthaelt(231)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(324)); + assertTrue(ba.enthaelt(851)); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(15)); + assertFalse(ba.enthaelt(223)); + assertTrue(ba.enthaelt(553)); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(419)); + assertFalse(ba.enthaelt(90)); + assertFalse(ba.enthaelt(221)); + assertFalse(ba.enthaelt(670)); + assertTrue(ba.enthaelt(876)); + assertFalse(ba.enthaelt(902)); + } + + @Test + public void test034() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(33)); + assertEquals(59,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(617)); + assertFalse(ba.enthaelt(253)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(190)); + assertFalse(ba.enthaelt(779)); + assertFalse(ba.enthaelt(994)); + assertFalse(ba.enthaelt(941)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(351)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(230)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(705)); + } + + @Test + public void test035() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(34)); + assertEquals(107,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(238)); + assertFalse(ba.enthaelt(35)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(137)); + assertTrue(ba.enthaelt(243)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(422)); + assertFalse(ba.enthaelt(930)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(251)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(206)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(79)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(384)); + assertTrue(ba.enthaelt(665)); + } + + @Test + public void test036() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(35)); + assertEquals(93,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(413)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(427)); + assertFalse(ba.enthaelt(660)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(191)); + assertTrue(ba.enthaelt(93)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(700)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test037() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(36)); + assertEquals(175,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(833)); + assertFalse(ba.enthaelt(408)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(559)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(281)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(920)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(726)); + assertFalse(ba.enthaelt(659)); + assertFalse(ba.enthaelt(786)); + assertFalse(ba.enthaelt(876)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(901)); + assertTrue(ba.enthaelt(260)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(782)); + } + + @Test + public void test038() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(37)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(947)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(185)); + assertTrue(ba.enthaelt(255)); + assertFalse(ba.enthaelt(684)); + assertTrue(ba.enthaelt(393)); + assertTrue(ba.enthaelt(88)); + assertFalse(ba.enthaelt(633)); + assertFalse(ba.enthaelt(220)); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(686)); + assertFalse(ba.enthaelt(579)); + assertTrue(ba.enthaelt(501)); + assertTrue(ba.enthaelt(616)); + assertTrue(ba.enthaelt(389)); + assertTrue(ba.enthaelt(285)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(253)); + } + + @Test + public void test039() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(38)); + assertEquals(129,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(572)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(116)); + assertFalse(ba.enthaelt(524)); + assertFalse(ba.enthaelt(569)); + assertFalse(ba.enthaelt(1)); + assertFalse(ba.enthaelt(794)); + assertFalse(ba.enthaelt(300)); + assertFalse(ba.enthaelt(865)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(408)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(154)); + assertTrue(ba.enthaelt(734)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(284)); + assertTrue(ba.enthaelt(628)); + } + + @Test + public void test040() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(39)); + assertEquals(281,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(848)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(878)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(38)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(634)); + assertFalse(ba.enthaelt(577)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(300)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(476)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(851)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(244)); + assertTrue(ba.enthaelt(401)); + } + + @Test + public void test041() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(40)); + assertEquals(117,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(517)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(382)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(733)); + assertTrue(ba.enthaelt(847)); + assertFalse(ba.enthaelt(741)); + assertFalse(ba.enthaelt(868)); + assertFalse(ba.enthaelt(785)); + assertTrue(ba.enthaelt(544)); + assertTrue(ba.enthaelt(302)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(449)); + assertTrue(ba.enthaelt(620)); + assertTrue(ba.enthaelt(465)); + assertTrue(ba.enthaelt(587)); + } + + @Test + public void test042() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(41)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(287)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(225)); + assertFalse(ba.enthaelt(224)); + assertTrue(ba.enthaelt(994)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(488)); + assertFalse(ba.enthaelt(746)); + assertTrue(ba.enthaelt(179)); + assertTrue(ba.enthaelt(1)); + assertTrue(ba.enthaelt(903)); + assertTrue(ba.enthaelt(522)); + assertTrue(ba.enthaelt(407)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(156)); + } + + @Test + public void test043() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(42)); + assertEquals(157,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(608)); + assertTrue(ba.enthaelt(375)); + assertFalse(ba.enthaelt(689)); + assertFalse(ba.enthaelt(856)); + assertTrue(ba.enthaelt(139)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(887)); + assertFalse(ba.enthaelt(481)); + assertFalse(ba.enthaelt(256)); + assertFalse(ba.enthaelt(182)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(114)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(744)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(362)); + assertTrue(ba.enthaelt(755)); + } + + @Test + public void test044() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(43)); + assertEquals(347,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(357)); + assertFalse(ba.enthaelt(718)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(58)); + assertFalse(ba.enthaelt(313)); + assertFalse(ba.enthaelt(530)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(402)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(751)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(220)); + assertFalse(ba.enthaelt(835)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(859)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(237)); + } + + @Test + public void test045() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(44)); + assertEquals(459,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(126)); + assertFalse(ba.enthaelt(328)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(597)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(747)); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(93)); + assertFalse(ba.enthaelt(866)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(228)); + assertTrue(ba.enthaelt(241)); + assertTrue(ba.enthaelt(335)); + assertTrue(ba.enthaelt(257)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(498)); + assertTrue(ba.enthaelt(366)); + } + + @Test + public void test046() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(45)); + assertEquals(187,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(916)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(361)); + assertFalse(ba.enthaelt(635)); + assertFalse(ba.enthaelt(991)); + assertTrue(ba.enthaelt(308)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(203)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(992)); + assertTrue(ba.enthaelt(72)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(357)); + assertTrue(ba.enthaelt(535)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(526)); + assertTrue(ba.enthaelt(483)); + } + + @Test + public void test047() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(46)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(174)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(522)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(578)); + assertTrue(ba.enthaelt(157)); + assertTrue(ba.enthaelt(830)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(307)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(23)); + } + + @Test + public void test048() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(47)); + assertEquals(81,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(763)); + assertFalse(ba.enthaelt(697)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(516)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(331)); + assertFalse(ba.enthaelt(602)); + assertFalse(ba.enthaelt(952)); + assertFalse(ba.enthaelt(928)); + assertTrue(ba.enthaelt(794)); + assertTrue(ba.enthaelt(342)); + assertTrue(ba.enthaelt(551)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(532)); + assertTrue(ba.enthaelt(86)); + assertTrue(ba.enthaelt(217)); + assertTrue(ba.enthaelt(921)); + assertTrue(ba.enthaelt(115)); + assertTrue(ba.enthaelt(32)); + } + + @Test + public void test049() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(48)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(394)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(400)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(569)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(1008)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(902)); + assertTrue(ba.enthaelt(41)); + assertFalse(ba.enthaelt(631)); + assertFalse(ba.enthaelt(927)); + assertTrue(ba.enthaelt(790)); + assertTrue(ba.enthaelt(464)); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(203)); + assertTrue(ba.enthaelt(774)); + } + + @Test + public void test050() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(49)); + assertEquals(73,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(942)); + assertFalse(ba.enthaelt(310)); + assertFalse(ba.enthaelt(44)); + assertFalse(ba.enthaelt(536)); + assertFalse(ba.enthaelt(512)); + assertTrue(ba.enthaelt(257)); + assertFalse(ba.enthaelt(219)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(474)); + assertTrue(ba.enthaelt(21)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(358)); + assertFalse(ba.enthaelt(651)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(309)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(502)); + } + + @Test + public void test051() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(50)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(199)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(721)); + assertFalse(ba.enthaelt(396)); + assertFalse(ba.enthaelt(318)); + assertFalse(ba.enthaelt(625)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(324)); + assertFalse(ba.enthaelt(913)); + assertTrue(ba.enthaelt(869)); + assertTrue(ba.enthaelt(541)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(937)); + assertTrue(ba.enthaelt(837)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(843)); + assertTrue(ba.enthaelt(236)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(752)); + } + + @Test + public void test052() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(51)); + assertEquals(437,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(352)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(708)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(281)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(410)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(555)); + assertFalse(ba.enthaelt(1004)); + assertFalse(ba.enthaelt(768)); + assertFalse(ba.enthaelt(774)); + assertTrue(ba.enthaelt(491)); + assertTrue(ba.enthaelt(589)); + assertFalse(ba.enthaelt(360)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(871)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(918)); + } + + @Test + public void test053() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(52)); + assertEquals(209,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(933)); + assertFalse(ba.enthaelt(77)); + assertFalse(ba.enthaelt(844)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(208)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(171)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(44)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(488)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(574)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(150)); + } + + @Test + public void test054() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(53)); + assertEquals(151,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(254)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(119)); + assertFalse(ba.enthaelt(605)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(738)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(27)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(1003)); + assertFalse(ba.enthaelt(971)); + assertFalse(ba.enthaelt(283)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(159)); + assertTrue(ba.enthaelt(505)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(126)); + } + + @Test + public void test055() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(54)); + assertEquals(311,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(619)); + assertTrue(ba.enthaelt(583)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(436)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(587)); + assertTrue(ba.enthaelt(880)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(225)); + assertFalse(ba.enthaelt(460)); + assertFalse(ba.enthaelt(501)); + assertFalse(ba.enthaelt(286)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(589)); + assertFalse(ba.enthaelt(773)); + assertTrue(ba.enthaelt(912)); + assertTrue(ba.enthaelt(671)); + assertTrue(ba.enthaelt(245)); + assertTrue(ba.enthaelt(145)); + } + + @Test + public void test056() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(55)); + assertEquals(93,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(232)); + assertFalse(ba.enthaelt(504)); + assertFalse(ba.enthaelt(951)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(575)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(255)); + assertFalse(ba.enthaelt(913)); + assertFalse(ba.enthaelt(592)); + assertFalse(ba.enthaelt(649)); + assertTrue(ba.enthaelt(897)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(128)); + assertTrue(ba.enthaelt(228)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(497)); + assertTrue(ba.enthaelt(317)); + assertTrue(ba.enthaelt(269)); + } + + @Test + public void test057() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(56)); + assertEquals(499,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(557)); + assertFalse(ba.enthaelt(863)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(116)); + assertFalse(ba.enthaelt(841)); + assertTrue(ba.enthaelt(683)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(783)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(87)); + assertTrue(ba.enthaelt(983)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(354)); + assertFalse(ba.enthaelt(155)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(725)); + assertTrue(ba.enthaelt(786)); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(1009)); + } + + @Test + public void test058() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(57)); + assertEquals(243,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(1004)); + assertTrue(ba.enthaelt(633)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(998)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(365)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(517)); + assertTrue(ba.enthaelt(242)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(337)); + assertTrue(ba.enthaelt(347)); + assertTrue(ba.enthaelt(133)); + } + + @Test + public void test059() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(58)); + assertEquals(875,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(665)); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(490)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(975)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(789)); + assertFalse(ba.enthaelt(625)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(818)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(566)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(886)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(463)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(84)); + } + + @Test + public void test060() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(59)); + assertEquals(251,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(81)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(998)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(1000)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(570)); + assertFalse(ba.enthaelt(104)); + assertTrue(ba.enthaelt(495)); + assertFalse(ba.enthaelt(584)); + assertFalse(ba.enthaelt(560)); + assertTrue(ba.enthaelt(623)); + assertFalse(ba.enthaelt(1005)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(360)); + assertTrue(ba.enthaelt(630)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(469)); + } + + @Test + public void test061() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(60)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(432)); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(998)); + assertTrue(ba.enthaelt(9)); + assertFalse(ba.enthaelt(940)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(951)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(392)); + assertTrue(ba.enthaelt(226)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(350)); + assertTrue(ba.enthaelt(799)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(836)); + } + + @Test + public void test062() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(61)); + assertEquals(85,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(192)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(869)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(3)); + assertTrue(ba.enthaelt(634)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(785)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(414)); + assertTrue(ba.enthaelt(579)); + } + + @Test + public void test063() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(62)); + assertEquals(221,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(251)); + assertFalse(ba.enthaelt(138)); + assertTrue(ba.enthaelt(803)); + assertFalse(ba.enthaelt(280)); + assertFalse(ba.enthaelt(62)); + assertFalse(ba.enthaelt(665)); + assertFalse(ba.enthaelt(429)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(656)); + assertTrue(ba.enthaelt(463)); + assertFalse(ba.enthaelt(131)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(26)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(167)); + assertTrue(ba.enthaelt(399)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(944)); + assertTrue(ba.enthaelt(625)); + } + + @Test + public void test064() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(63)); + assertEquals(115,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(690)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(525)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(28)); + assertFalse(ba.enthaelt(622)); + assertFalse(ba.enthaelt(270)); + assertFalse(ba.enthaelt(731)); + assertTrue(ba.enthaelt(38)); + assertTrue(ba.enthaelt(479)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(24)); + assertTrue(ba.enthaelt(754)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(289)); + } + + @Test + public void test065() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(64)); + assertEquals(513,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(579)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(598)); + assertFalse(ba.enthaelt(303)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(776)); + assertFalse(ba.enthaelt(522)); + assertTrue(ba.enthaelt(323)); + assertFalse(ba.enthaelt(168)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(922)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(113)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(866)); + } + + @Test + public void test066() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(65)); + assertEquals(79,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(441)); + assertTrue(ba.enthaelt(976)); + assertFalse(ba.enthaelt(797)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(159)); + assertFalse(ba.enthaelt(305)); + assertFalse(ba.enthaelt(486)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(216)); + assertTrue(ba.enthaelt(696)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(225)); + } + + @Test + public void test067() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(66)); + assertEquals(145,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(588)); + assertFalse(ba.enthaelt(860)); + assertTrue(ba.enthaelt(451)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(634)); + assertFalse(ba.enthaelt(154)); + assertTrue(ba.enthaelt(146)); + assertFalse(ba.enthaelt(581)); + assertFalse(ba.enthaelt(778)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(580)); + assertFalse(ba.enthaelt(685)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(106)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(173)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(249)); + assertTrue(ba.enthaelt(244)); + } + + @Test + public void test068() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(67)); + assertEquals(653,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(950)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(543)); + assertTrue(ba.enthaelt(161)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(135)); + assertTrue(ba.enthaelt(119)); + assertTrue(ba.enthaelt(379)); + assertFalse(ba.enthaelt(9)); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(634)); + assertTrue(ba.enthaelt(215)); + assertFalse(ba.enthaelt(345)); + assertTrue(ba.enthaelt(326)); + assertFalse(ba.enthaelt(948)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(803)); + assertTrue(ba.enthaelt(463)); + assertTrue(ba.enthaelt(212)); + } + + @Test + public void test069() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(68)); + assertEquals(231,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(343)); + assertFalse(ba.enthaelt(195)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(377)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(643)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(771)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(198)); + } + + @Test + public void test070() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(69)); + assertEquals(241,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(982)); + assertFalse(ba.enthaelt(326)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(71)); + assertFalse(ba.enthaelt(494)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(915)); + assertTrue(ba.enthaelt(100)); + assertFalse(ba.enthaelt(215)); + assertFalse(ba.enthaelt(48)); + assertFalse(ba.enthaelt(5)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(908)); + assertTrue(ba.enthaelt(451)); + assertTrue(ba.enthaelt(258)); + assertTrue(ba.enthaelt(473)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(734)); + } + + @Test + public void test071() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(70)); + assertEquals(147,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(803)); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(464)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(439)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(494)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(113)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(644)); + assertTrue(ba.enthaelt(537)); + assertTrue(ba.enthaelt(471)); + assertTrue(ba.enthaelt(70)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(581)); + } + + @Test + public void test072() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(71)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(675)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(105)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(328)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(466)); + assertFalse(ba.enthaelt(572)); + assertTrue(ba.enthaelt(499)); + assertFalse(ba.enthaelt(218)); + assertTrue(ba.enthaelt(518)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(32)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(152)); + assertTrue(ba.enthaelt(19)); + } + + @Test + public void test073() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(72)); + assertEquals(231,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(908)); + assertTrue(ba.enthaelt(138)); + assertFalse(ba.enthaelt(1012)); + assertFalse(ba.enthaelt(189)); + assertTrue(ba.enthaelt(745)); + assertFalse(ba.enthaelt(799)); + assertTrue(ba.enthaelt(922)); + assertTrue(ba.enthaelt(595)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(31)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(348)); + assertTrue(ba.enthaelt(850)); + assertTrue(ba.enthaelt(162)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(388)); + assertTrue(ba.enthaelt(694)); + } + + @Test + public void test074() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(73)); + assertEquals(191,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(92)); + assertFalse(ba.enthaelt(929)); + assertTrue(ba.enthaelt(312)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(529)); + assertFalse(ba.enthaelt(567)); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(788)); + assertTrue(ba.enthaelt(487)); + assertTrue(ba.enthaelt(330)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(77)); + assertTrue(ba.enthaelt(624)); + assertTrue(ba.enthaelt(722)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(215)); + } + + @Test + public void test075() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(74)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(561)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(230)); + assertFalse(ba.enthaelt(40)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(624)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(394)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(951)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(364)); + assertTrue(ba.enthaelt(293)); + assertTrue(ba.enthaelt(58)); + assertTrue(ba.enthaelt(798)); + assertTrue(ba.enthaelt(51)); + } + + @Test + public void test076() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(75)); + assertEquals(63,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(251)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(214)); + assertFalse(ba.enthaelt(963)); + assertFalse(ba.enthaelt(921)); + assertTrue(ba.enthaelt(278)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(302)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(640)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(419)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(385)); + } + + @Test + public void test077() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(76)); + assertEquals(265,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(59)); + assertTrue(ba.enthaelt(384)); + assertFalse(ba.enthaelt(286)); + assertTrue(ba.enthaelt(195)); + assertFalse(ba.enthaelt(432)); + assertTrue(ba.enthaelt(591)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(867)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(981)); + assertFalse(ba.enthaelt(32)); + assertFalse(ba.enthaelt(782)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(804)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(129)); + assertTrue(ba.enthaelt(483)); + assertTrue(ba.enthaelt(372)); + } + + @Test + public void test078() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(77)); + assertEquals(211,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(520)); + assertFalse(ba.enthaelt(832)); + assertTrue(ba.enthaelt(98)); + assertFalse(ba.enthaelt(240)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(237)); + assertFalse(ba.enthaelt(873)); + assertFalse(ba.enthaelt(672)); + assertFalse(ba.enthaelt(269)); + assertTrue(ba.enthaelt(115)); + assertFalse(ba.enthaelt(493)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(766)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(519)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(114)); + } + + @Test + public void test079() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(78)); + assertEquals(77,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(274)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(175)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(191)); + assertFalse(ba.enthaelt(640)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(950)); + assertTrue(ba.enthaelt(14)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(402)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(747)); + } + + @Test + public void test080() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(79)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(89)); + assertTrue(ba.enthaelt(366)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(825)); + assertFalse(ba.enthaelt(289)); + assertFalse(ba.enthaelt(1016)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(326)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(239)); + assertTrue(ba.enthaelt(139)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(286)); + } + + @Test + public void test081() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(80)); + assertEquals(577,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(821)); + assertFalse(ba.enthaelt(446)); + assertTrue(ba.enthaelt(748)); + assertFalse(ba.enthaelt(400)); + assertTrue(ba.enthaelt(505)); + assertFalse(ba.enthaelt(898)); + assertTrue(ba.enthaelt(10)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(222)); + assertFalse(ba.enthaelt(977)); + assertTrue(ba.enthaelt(555)); + assertTrue(ba.enthaelt(870)); + assertFalse(ba.enthaelt(845)); + assertTrue(ba.enthaelt(795)); + assertTrue(ba.enthaelt(12)); + assertTrue(ba.enthaelt(233)); + assertFalse(ba.enthaelt(731)); + } + + @Test + public void test082() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(81)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(508)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(770)); + assertFalse(ba.enthaelt(1010)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(15)); + assertTrue(ba.enthaelt(418)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(299)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(768)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(629)); + assertTrue(ba.enthaelt(844)); + } + + @Test + public void test083() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(82)); + assertEquals(393,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(560)); + assertFalse(ba.enthaelt(646)); + assertTrue(ba.enthaelt(558)); + assertFalse(ba.enthaelt(8)); + assertFalse(ba.enthaelt(683)); + assertFalse(ba.enthaelt(805)); + assertTrue(ba.enthaelt(668)); + assertTrue(ba.enthaelt(434)); + assertTrue(ba.enthaelt(483)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(137)); + assertTrue(ba.enthaelt(239)); + assertFalse(ba.enthaelt(747)); + assertTrue(ba.enthaelt(583)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(717)); + } + + @Test + public void test084() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(83)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(805)); + assertFalse(ba.enthaelt(725)); + assertFalse(ba.enthaelt(434)); + assertTrue(ba.enthaelt(289)); + assertFalse(ba.enthaelt(330)); + assertTrue(ba.enthaelt(130)); + assertFalse(ba.enthaelt(876)); + assertFalse(ba.enthaelt(812)); + assertFalse(ba.enthaelt(989)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(594)); + assertTrue(ba.enthaelt(673)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(940)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test085() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(84)); + assertEquals(123,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(332)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(197)); + assertTrue(ba.enthaelt(188)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(59)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(200)); + assertTrue(ba.enthaelt(265)); + assertFalse(ba.enthaelt(320)); + assertTrue(ba.enthaelt(969)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(190)); + assertTrue(ba.enthaelt(664)); + assertFalse(ba.enthaelt(1010)); + assertTrue(ba.enthaelt(340)); + assertTrue(ba.enthaelt(679)); + assertTrue(ba.enthaelt(909)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(416)); + } + + @Test + public void test086() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(85)); + assertEquals(425,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(406)); + assertFalse(ba.enthaelt(372)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(108)); + assertFalse(ba.enthaelt(158)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(581)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(692)); + assertFalse(ba.enthaelt(127)); + assertTrue(ba.enthaelt(593)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(492)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(90)); + assertTrue(ba.enthaelt(457)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(209)); + assertTrue(ba.enthaelt(180)); + } + + @Test + public void test087() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(86)); + assertEquals(43,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(247)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(117)); + assertFalse(ba.enthaelt(733)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(530)); + assertFalse(ba.enthaelt(363)); + assertFalse(ba.enthaelt(827)); + assertFalse(ba.enthaelt(995)); + assertFalse(ba.enthaelt(926)); + assertTrue(ba.enthaelt(294)); + assertTrue(ba.enthaelt(759)); + assertTrue(ba.enthaelt(972)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(450)); + } + + @Test + public void test088() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(87)); + assertEquals(579,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(1017)); + assertFalse(ba.enthaelt(557)); + assertTrue(ba.enthaelt(742)); + assertFalse(ba.enthaelt(95)); + assertFalse(ba.enthaelt(748)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(612)); + assertFalse(ba.enthaelt(131)); + assertTrue(ba.enthaelt(433)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(739)); + assertTrue(ba.enthaelt(831)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(368)); + assertFalse(ba.enthaelt(674)); + assertTrue(ba.enthaelt(889)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(13)); + assertTrue(ba.enthaelt(350)); + } + + @Test + public void test089() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(88)); + assertEquals(229,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(37)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(642)); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(38)); + assertFalse(ba.enthaelt(859)); + assertTrue(ba.enthaelt(324)); + assertFalse(ba.enthaelt(475)); + assertTrue(ba.enthaelt(793)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(480)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(466)); + assertTrue(ba.enthaelt(984)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(721)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(517)); + } + + @Test + public void test090() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(89)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(686)); + assertFalse(ba.enthaelt(84)); + assertFalse(ba.enthaelt(210)); + assertFalse(ba.enthaelt(541)); + assertTrue(ba.enthaelt(775)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(133)); + assertTrue(ba.enthaelt(578)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(750)); + assertFalse(ba.enthaelt(295)); + assertFalse(ba.enthaelt(19)); + assertTrue(ba.enthaelt(278)); + assertTrue(ba.enthaelt(189)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(511)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(39)); + } + + @Test + public void test091() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(90)); + assertEquals(329,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(698)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(467)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(897)); + assertTrue(ba.enthaelt(533)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(538)); + assertFalse(ba.enthaelt(142)); + assertFalse(ba.enthaelt(667)); + assertTrue(ba.enthaelt(783)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(48)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(478)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(834)); + } + + @Test + public void test092() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(91)); + assertEquals(87,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(77)); + assertTrue(ba.enthaelt(369)); + assertFalse(ba.enthaelt(596)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(899)); + assertFalse(ba.enthaelt(901)); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(785)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(98)); + assertTrue(ba.enthaelt(996)); + assertTrue(ba.enthaelt(356)); + assertTrue(ba.enthaelt(688)); + assertTrue(ba.enthaelt(746)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(92)); + assertTrue(ba.enthaelt(238)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(105)); + } + + @Test + public void test093() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(92)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(185)); + assertFalse(ba.enthaelt(447)); + assertFalse(ba.enthaelt(401)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(535)); + assertFalse(ba.enthaelt(886)); + assertFalse(ba.enthaelt(775)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(988)); + assertTrue(ba.enthaelt(67)); + assertTrue(ba.enthaelt(678)); + assertTrue(ba.enthaelt(50)); + assertTrue(ba.enthaelt(144)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(636)); + assertTrue(ba.enthaelt(633)); + assertTrue(ba.enthaelt(296)); + assertTrue(ba.enthaelt(947)); + } + + @Test + public void test094() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(93)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(965)); + assertFalse(ba.enthaelt(826)); + assertFalse(ba.enthaelt(551)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(11)); + assertFalse(ba.enthaelt(497)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(177)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(816)); + assertTrue(ba.enthaelt(26)); + assertTrue(ba.enthaelt(80)); + assertTrue(ba.enthaelt(824)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(37)); + assertTrue(ba.enthaelt(943)); + assertTrue(ba.enthaelt(363)); + } + + @Test + public void test095() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(94)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(313)); + assertTrue(ba.enthaelt(769)); + assertFalse(ba.enthaelt(74)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(473)); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(663)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(783)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(531)); + assertTrue(ba.enthaelt(625)); + assertTrue(ba.enthaelt(186)); + assertTrue(ba.enthaelt(442)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(999)); + } + + @Test + public void test096() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(95)); + assertEquals(79,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(630)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(926)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(214)); + assertTrue(ba.enthaelt(63)); + assertFalse(ba.enthaelt(329)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(934)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(256)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(441)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(333)); + } + + @Test + public void test097() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(96)); + assertEquals(141,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(98)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(15)); + assertFalse(ba.enthaelt(931)); + assertFalse(ba.enthaelt(265)); + assertFalse(ba.enthaelt(226)); + assertTrue(ba.enthaelt(639)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(150)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(281)); + assertTrue(ba.enthaelt(510)); + assertTrue(ba.enthaelt(428)); + assertTrue(ba.enthaelt(631)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(12)); + } + + @Test + public void test098() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(97)); + assertEquals(139,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(889)); + assertFalse(ba.enthaelt(987)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(33)); + assertFalse(ba.enthaelt(485)); + assertFalse(ba.enthaelt(482)); + assertFalse(ba.enthaelt(946)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(227)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(763)); + assertTrue(ba.enthaelt(63)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(57)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(401)); + assertTrue(ba.enthaelt(301)); + assertTrue(ba.enthaelt(214)); + assertTrue(ba.enthaelt(30)); + } + + @Test + public void test099() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(98)); + assertEquals(169,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(714)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(597)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(760)); + assertTrue(ba.enthaelt(610)); + assertFalse(ba.enthaelt(411)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(127)); + assertFalse(ba.enthaelt(541)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(379)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(568)); + assertTrue(ba.enthaelt(156)); + assertTrue(ba.enthaelt(882)); + assertTrue(ba.enthaelt(952)); + assertTrue(ba.enthaelt(102)); + } + + @Test + public void test100() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(99)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(307)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(273)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(697)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(387)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(396)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(28)); + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Baumalgorithmen.java b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Baumalgorithmen.java new file mode 100644 index 0000000..38fa9e7 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Baumalgorithmen.java @@ -0,0 +1,120 @@ + +/** + * Führt verschiedene Algorithmen auf Binärbäumen aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Baumalgorithmen +{ + /** + * Die Wurzel des Baums, mit dem der Algorithmus durchgeführt werden soll + */ + protected Binaerbaum wurzel; + + /** + * Erzeugt ein neues Algorithmen-Objekt + * @param wurzel Die Wurzel des Baums, der verarbeitet werden soll + */ + public Baumalgorithmen(Binaerbaum wurzel) + { + this.wurzel = wurzel; + } + + /** + * Zeigt den Baum auf der Konsole an. + */ + public void baumAnzeigen() + { + if (wurzel != null) + { + System.out.println(wurzel.daten); + baumAnzeigen(wurzel.links, "", true); + baumAnzeigen(wurzel.rechts, "", false); + } + } + + private void baumAnzeigen(Binaerbaum b, String indent, boolean left) + { + System.out.print(indent); + System.out.print(left ? "\u251C " : "\u2514 "); + if (b != null) + { + System.out.println(b.daten); + if (b.links != null || b.rechts != null) + { + indent += (left ? "\u2502 " : " "); + baumAnzeigen(b.links, indent, true); + baumAnzeigen(b.rechts, indent, false); + } + } + else + { + System.out.println(""); + } + } + + /** + * Gibt die Tiefe des Baums zurück + * @return Die Tiefe des Baums, gezählt ab der Wurzel + */ + public int tiefe() + { + return tiefe(wurzel); + } + + /** + * Gibt die Tiefe eines Baums zurück + * @param b Der Baum, dessen Tiefe bestimmt werden soll + * @return Die Tiefe des Baums, gezählt ab b + */ + private int tiefe(Binaerbaum b) + { + //# TODO: Bestimmen Sie die Tiefe des Binärbaums b. + //# Ein leerer Baum hat nach Definition die Tiefe 0. + //# Ein Blatt hat die Tiefe 1. + return 0; + } + + /** + * Gibt die Anzahl der Knoten im Baums zurück + * @return Die Anzahl aller Knoten im Baum + */ + public int anzahl() + { + return anzahl(wurzel); + } + + /** + * Gibt die Anzahl der Knoten in einem Baums zurück + * @param b Der Baum, in dem die Knoten gezählt werden sollen + * @return Die Anzahl der Knoten, die sich von b an im Baum befinden (inklusive b) + */ + private int anzahl(Binaerbaum b) + { + //# TODO: Bestimmen Sie die Anzahl der Knoten des Binärbaums b mit seinen Unterbäumen. + return 0; + } + + /** + * Prüft, ob sich ein Wert im Baum befindet + * @param wert Der zu suchende Wert + * @return true, wenn ein Knoten den Wert enthält; false sonst + */ + public boolean enthaelt(T wert) + { + return enthaelt(wurzel, wert); + } + + /** + * Prüft, ob sich ein Wert in b oder darunter befindet + * @param b Der Baum, in dem der Wert gesucht werden soll + * @return true, wenn b oder einer seiner Kindknoten den Wert enthält; false sonst + */ + private boolean enthaelt(Binaerbaum b, T wert) + { + //# TODO: Bestimmen Sie, ob der Binärbaum b oder einer seiner Unterbäume den Wert wert enthält. + //# Achtung: Ein Vergleich muss mit equals durchgeführt werden. + return false; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Binaerbaum.java b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/README.TXT b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/README.TXT new file mode 100644 index 0000000..ee5db68 Binary files /dev/null and b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/README.TXT differ diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Testbaeume.java b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Testbaeume.java new file mode 100644 index 0000000..a7f9076 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/Testbaeume.java @@ -0,0 +1,75 @@ +import java.util.ArrayList; +import java.io.FileReader; +import java.io.BufferedReader; +import java.util.ArrayList; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Liest Testbäume aus einer Datei aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Testbaeume +{ + /** + * Die aus der Datei eingelesenen Bäume + */ + static ArrayList> baeume; + + private static void readFile() + { + try + { + FileReader fileReader = new FileReader("testfaelle.txt"); + BufferedReader bufferedReader = new BufferedReader(fileReader); + baeume = new ArrayList>(); + String line = null; + while ((line = bufferedReader.readLine()) != null) { + AtomicInteger ai = new AtomicInteger(0); + Binaerbaum b = parse(line.toCharArray(), ai); + baeume.add(b); + } + bufferedReader.close(); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + baeume = null; + } + } + + private static Binaerbaum parse(char[] c, AtomicInteger s) + { + int anfang = s.incrementAndGet(); + while(c[s.get()] != '(' && c[s.get()] != ')') + { + s.incrementAndGet(); + } + String tmp = new String(c, anfang, s.get()-anfang); + int value = Integer.parseInt(tmp); + Binaerbaum ergebnis = new Binaerbaum(value); + if (c[s.get()] == '(') + { + ergebnis.links = parse(c, s); + s.incrementAndGet(); + ergebnis.rechts = parse(c, s); + s.incrementAndGet(); + } + return ergebnis; + } + + /** + * Gibt einen der Testbäume aus der Datei zurück + * @param nummer Die Nummer des Baums + * @return Den gewünschten Baum, wenn die Nummer gültig ist; null sonst + */ + public static Binaerbaum getTestBaum(int nummer) + { + if (baeume == null) + readFile(); + if (nummer >= 0 && nummer < baeume.size()) + return baeume.get(nummer); + return null; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/package.bluej b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/package.bluej new file mode 100644 index 0000000..89cde6b --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/package.bluej @@ -0,0 +1,65 @@ +#BlueJ package file +dependency1.from=Baumalgorithmen +dependency1.to=Binaerbaum +dependency1.type=UsesDependency +dependency2.from=BaumTester +dependency2.to=Baumalgorithmen +dependency2.type=UsesDependency +dependency3.from=BaumTester +dependency3.to=Testbaeume +dependency3.type=UsesDependency +dependency4.from=Testbaeume +dependency4.to=Binaerbaum +dependency4.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +objectbench.height=93 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8 +package.editor.height=393 +package.editor.width=649 +package.editor.x=62 +package.editor.y=344 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=4 +package.numTargets=4 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Binaerbaum +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=170 +target1.y=60 +target2.height=50 +target2.name=Baumalgorithmen +target2.showInterface=false +target2.type=ClassTarget +target2.width=160 +target2.x=300 +target2.y=130 +target3.height=50 +target3.name=BaumTester +target3.showInterface=false +target3.type=UnitTestTargetJunit4 +target3.width=100 +target3.x=460 +target3.y=210 +target4.height=50 +target4.name=Testbaeume +target4.showInterface=false +target4.type=ClassTarget +target4.width=100 +target4.x=80 +target4.y=260 diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/testfaelle.txt b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/testfaelle.txt new file mode 100644 index 0000000..7c0595c --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/01_baumalgorithmen_roh/testfaelle.txt @@ -0,0 +1,100 @@ +(366(518(665(284(101(853(360(314(190(465(386(162)(241))(459(197)(861)))(654(427(528)(255))(351(835)(533))))(445(394)(717(311)(530(253)(429)))))(756))(749(236(53(339(469(265)(695))(642(837)(192)))(860))(215))(618(340)(547(201(410)(811(37)(331)))(567)))))(130))(685(76(105(293(837)(262))(3(766)(875(161)(773(65(505)(939))(351(33)(379))))))(94))(301(90(820(166(63(931(73)(590))(936(439)(190)))(990(270(240)(807))(795)))(194(919(694)(244(430)(243)))(924)))(468(420(668)(282(73(966)(860))(270(400)(608))))(914(467)(402(915(547)(648))(96(715)(255))))))(259(870(672(733)(854(327(778)(811))(150)))(629(398(837)(333(203)(270)))(104(749(730)(534))(59(668)(940)))))(769(130)(366(408)(674)))))))(512(869(507(359(823(542)(799(713(910(693)(435))(319(663)(736)))(198)))(992))(682))(73(49)(872)))(715(628)(297))))(274(532(581(418(844)(325))(747(420(97(426(902)(991(682(440)(307))(361(493)(173))))(82(739)(645)))(493(837(182)(720(245)(817(498)(968))))(831(302)(939(429(907)(473))(914)))))(859(111(802(413(303)(291))(432(883(20)(891))(560(263)(932))))(874(85(679(130)(79))(2(761)(596)))(959(675(66)(894))(847(899)(364)))))(448))))(844(446)(690(377)(561))))(615(266)(757(612)(509(374)(641(998(367(40(223(598)(359))(129(700)(312)))(539(534(127)(583))(351(551)(108))))(276))(111(860(406(706(561)(854))(298))(680))(919))))))))(830(154(760(719(29)(9(395(471(575(625)(960(743(939)(344))(499)))(413(186(60(224)(691))(951(821)(906)))(320)))(640(555(914)(820))(910(657(725(105)(879))(896(538)(806)))(572(13(175)(254))(362(276)(664))))))(118(129(973(588)(843(20)(212(115)(2))))(300))(215(15(322)(317(144(646)(549))(411)))(50(274(452(129)(879))(454(473)(758)))(568(13(766)(542))(981(129)(211))))))))(170))(900(132(614(589(526)(550))(379(947(268(789(787(255)(889))(234))(258(112(9)(669))(593(871)(191))))(248))(451(474(35(112(436)(165))(930(550)(739)))(339(271)(745(56)(905))))(790(981)(562(33(737)(533))(648(530)(140)))))))(488))(136)))(123(832(708(637(395)(156))(360))(71(498(989(10(571)(964(248(460)(751(848)(925)))(626)))(758))(190(357(999(155)(944(210(223)(239))(687(125)(817))))(395))(593(170(119)(73(269(614)(685))(84)))(185(672)(587(80)(633))))))(198(495(107)(91(487(163(178)(628(935)(376)))(977(513)(648)))(925)))(546(595)(908(440)(557(74)(328(318(304)(292))(883(209)(198)))))))))(459(108)(358(450(817)(161))(233(503(321)(365(295)(392(811)(18(807(785)(268))(821)))))(757))))))) +(796(145(612(934(49(576)(126(436(825(199)(657))(983(245)(286)))(942(105)(545))))(42(514(577)(575(8(157)(275))(617(534)(266))))(714(783(935(907)(964))(88(376)(912)))(653(24(199)(221))(244(526)(50))))))(829(186(24(829(855(529)(692))(429(635)(202)))(932(306)(120)))(368(495)(41(566)(512(591)(478)))))(4(650(339(8(605)(714))(203(926)(92)))(480(778(367)(273))(414(4)(191))))(102(889(558(413)(379))(159(931)(866)))(514)))))(743(286(669)(277(800(656)(842))(576(680(913(429)(355))(445(51)(681)))(311))))(194)))(273(760(978(506)(240(273(592(409(521)(731))(937(463)(941)))(284))(839(932)(502(996(396)(90))(444)))))(56(620(37(872)(131(377(950)(185))(416)))(170(22(834(726)(208))(247(839)(205)))(597(103(154)(349))(810))))(109)))(886(39)(9(499(597(217)(763(530(174)(699))(257(904)(185))))(54(556(310(258)(475))(382(66)(187)))(995(958)(993(604)(14)))))(502(827)(808(131)(428(580(983)(342))(388)))))))) +(683(388(163(757)(113(798(174)(612(46(595)(66))(674(828)(41))))(837(948)(258(646(887)(334))(441(959)(15))))))(744(332(589)(551(671(661)(186(43)(947)))(681(301(229)(228))(419(887)(865)))))(207)))(954(649(258(654(185(288)(577(9)(344)))(661))(251))(435(410(565(15(469)(812))(665))(33))(917)))(770(69(985(916)(629(968)(719)))(656(628(39(481)(590))(210(705)(518)))(785(914)(995(221)(913)))))(861(435(98(150(51)(562))(343(706)(189)))(607))(219(404(741(216)(249))(423(258)(347)))(904(417(770)(210))(691(104)(997)))))))) +(163(852(819(592(619(567(235(402)(879(960)(406(195)(948))))(669(976(604(382)(740))(284))(611(837)(69(328)(239)))))(271))(870(664(295)(145(255)(36)))(876(194)(712(318(31)(915))(351)))))(475(45)(991)))(335(743(755)(441))(814(763(950(321(350)(387(947(374)(845))(38)))(849(23(344)(652(250)(120)))(988(691(304)(951))(110))))(705(909(916(751)(189))(747(450(764)(834))(394(517)(35))))(585(864)(9(673(898)(179))(76(160)(447))))))(731(392(446)(381))(540(656(864(0)(367(693)(629)))(305(0(125)(838))(535(938)(768))))(178(488(744(415)(328))(595))(422(371(6)(235))(884(7)(398)))))))))(946(361(346)(711(14(616(523(666(232(648)(755))(728))(870(901(690)(411))(864(527)(334))))(349(958)(27(805(192)(926))(986))))(311))(105(73(250)(466))(829(43(210(547(955)(206))(842(637)(520)))(690(984(704)(385))(715)))(277)))))(192(118)(909(177)(488(363(453(752(711(252)(343))(616(279)(315)))(62(250(718)(464))(853)))(280))(86(183(905)(319))(545(502(153(524)(28))(234(654)(538)))(207(202(196)(925))(751(611)(540)))))))))) +(428(369(333(668(626(728(715(766(113)(716))(358(119)(581)))(792(313(214)(593))(205)))(32(858(988(487)(810))(621(586)(659)))(252(958(882)(514))(464(532)(840)))))(290(185(646(134(972)(477))(24(20)(865)))(399))(639(98(814)(127))(285))))(598(719)(631(631(694(304(356)(372))(964))(295(295(351)(625))(950(934)(653))))(471))))(956(283)(918(849(594(297(774(27)(354))(217(657)(825)))(77(634(185)(308))(111(4)(151))))(944(344)(375(186(396)(331))(177(727)(9)))))(133))))(99(272(200(740(632)(544(484)(958(464(67)(779))(948(915)(280)))))(477(421(114)(232))(67(277)(374))))(481))(441(952)(513(805(383)(271(610(991(943)(145))(439))(614(404(885)(884))(854))))(55))))) +(954(577(3(685(175(779)(365))(287(144)(836(706(119(312)(761))(557(73)(706)))(131(270(116)(381))(780)))))(216))(325(688(803(795(820)(525(572(4)(406))(757(601)(139))))(398))(528(589(176)(624(174(924)(770))(665)))(175(131)(373(254(835)(548))(110)))))(695(329(432)(136(60(100(202)(814))(507(520)(797)))(760(51)(834(867)(706)))))(568))))(734(449(453(865(372(14(423(909)(290))(489(357)(387)))(769))(131(165(83(3)(125))(62(892)(339)))(984(948(401)(423))(211(174)(525)))))(881))(491(850(4)(984(661)(297(312(741)(482))(326))))(141(768(319)(362(514)(961(78)(74))))(429(163(214(626)(417))(955(995)(411)))(774(262(570)(615))(701(753)(589)))))))(429(438(800(925)(168(983(992(905)(385))(362))(985)))(787))(675(764)(437(426(113)(38(884(13)(940))(752(625)(850))))(754(404)(45(677)(371)))))))) +(606(112(79(954)(960(122(347)(738(153(282(599)(182(702)(486)))(625(947(281)(667))(908(737)(30))))(547(894(892(645)(443))(909(3)(250)))(382(510(87)(553))(527(891)(916))))))(513(122(687(590(644)(378(496)(371)))(384(990(33)(526))(245(28)(810))))(466))(867))))(368(44(945)(632))(609(491(319(623(672)(43(292(275)(338))(40(268)(814))))(227))(936))(438))))(230(982(227)(924))(472(274(834(642)(916(266)(910)))(39))(379(505(863(557(492(353(564)(821))(33))(903(916(976)(447))(866)))(181(461(472)(769))(471)))(831(557(779)(836))(791(595(552)(443))(424))))(409(157(449(833(371(734)(276))(253(14)(773)))(981(853(792)(647))(0)))(999(660(110)(106(904)(231)))(178(126(941)(259))(369))))(69(263(565(454(473)(83))(828(438)(494)))(249(889(822)(405))(732(470)(264))))(453(200(341)(829(952)(810)))(381(78)(822(640)(995)))))))))) +(911(409(461(415)(644(343(732(308)(141))(219))(897(809(70)(642(978(138(879(224)(511(639)(526)))(744(799(189)(993))(976(946)(792))))(723(388)(125(744)(850))))(427(56(117(402)(708(547)(664)))(179(572(615)(248))(13(590)(296))))(645(413(742(584)(789))(208(771)(254)))(601(84(191)(813))(955(871)(166)))))))(313))))(599(187)(279)))(988(300(428(234(90(964(998)(707))(383(586(754(413(130)(204))(204))(439(53)(481(369(761)(90))(790(7)(27)))))(797(651(371)(490(543(735)(681))(298)))(982))))(848(301)(195)))(320))(178(776(474(407(794)(926(766(991(543(883)(3))(452(725)(134)))(14(79)(254(189)(389))))(479(847(752(427)(229))(131(866)(13)))(56))))(159(760(980(696)(107(54)(624(247)(944))))(6(637)(641)))(699)))(993(188(93(854(51)(217(980(791)(542))(501)))(143(398(439(871)(102))(615(983)(268)))(651(17)(754))))(784(781(482(163)(568(233)(416)))(392(982(892)(797))(377(648)(516))))(920(691(654(685)(75))(539))(134(47)(334(398)(829))))))(829(174(509(692(882)(18(581)(772)))(68))(699(836(792)(243))(558(831)(935(435)(193)))))(712))))(42(677(447(116(976(326)(840(354)(300(677)(729))))(736(383(184(317)(823))(408(89)(806)))(175(556)(922))))(875(196(931)(848(286(175)(274))(428(625)(905))))(103(661(574(713)(900))(394(562)(583)))(915))))(84(940(153)(482))(561(775(890(539(164)(416))(290(763)(984)))(5))(888))))(270(52(788(412(179)(201(388)(480(585)(231))))(259(463)(542(918)(412(453)(615)))))(313))(139)))))(389(964(60(636)(456(688(33)(293(946)(310(872(915(749)(657))(544(40)(984)))(851(557(258)(322))(271(63)(619))))))(632(64(959(615(501)(760(716)(853)))(666(360(427)(5))(566(120)(108))))(234(7(834)(320(781)(838)))(169(144(798)(625))(129(969)(647)))))(154))))(378(99)(287(198(565(105(960(865(851)(354))(342))(638(742(229)(493))(731)))(165(331(317(449)(192))(838))(421(585(669)(552))(233(938)(966)))))(630))(937))))(984(785(202)(192(319(370(663)(14))(438(704(702)(299(991(474)(591))(792(27)(188))))(596)))(803)))(811))))) +(789(549(347(66)(232(216)(334(182)(771(733)(213)))))(807(391(900(181)(983(290(105)(717(802)(875(18)(266(832)(179)))))(944(487(168(221(36)(79))(513(531)(955)))(532))(397(834(826(216)(937))(761))(667(441(870)(464))(67(457)(623)))))))(403(134)(698)))(592(222(425(952)(111))(483(626(25(202)(359(735(95)(950))(428(898)(334))))(495))(239)))(21(768)(224(122(958(980(480(333)(265))(191(7)(974)))(197))(643))(900(552(454(628(925)(864))(422(345)(883)))(459))(639)))))))(215(987(991)(473))(699(657(369(69(666(555(907(220(94)(769))(765(878)(666)))(866(516(874)(942))(955(75)(348))))(117(621(193(670)(94))(343(388)(950)))(269(272(667)(787))(87(684)(161)))))(997(613)(658(853)(680(801(479)(117))(381(100)(866))))))(298))(29(993)(268(135(115(994(554)(787))(709))(56))(889))))(582(343)(698))))) +(78(894(236(464)(309(794(437(372)(581))(604(967(426(157)(869))(411(808)(462)))(361(500(698)(610))(711(184)(755)))))(623(224(102)(360(572(35)(492))(698)))(781(916(150(750)(434))(296))(33(562)(293(286)(7)))))))(334(974(756)(757(272)(867(866(772)(881(776)(845)))(470(147)(950(939)(295))))))(52(64(783(689)(848(710)(702(315)(234))))(659))(553(261(355(730)(375(945)(477)))(391(974(579)(747))(257(662)(578))))(472)))))(781(562(312(370(643(904(223)(218(273)(576)))(933(151(110)(185))(418(680)(805))))(213(766(980)(479(976)(952)))(860)))(303(383(994)(744))(117)))(477))(88(709(182)(224(431)(514)))(205(445(684(593(864)(920(184)(590)))(714(664(890)(466))(70)))(578))(161(686)(43)))))) +(625(138(24(127)(87(799(704(45(53(762(592)(632(920)(338)))(26(134(8)(482))(441)))(133))(520(326(508(762(997)(197))(209(870)(273)))(890(275(700)(789))(9)))(712(325)(968(46(210)(645))(815(185)(127))))))(711(121(742)(591(675(143(800)(138))(633))(558(157)(651))))(758(642(309(430)(276(967)(339)))(425))(295(230)(158(642(98)(146))(353))))))(917)))(792(49(249(953(481(183(753(150)(154(551)(29)))(448(589(229)(760))(83(749)(860))))(131))(91(797(135(888(470)(964))(922(762)(823)))(971))(964)))(223(152)(352(83(590(300)(861))(933(331(640)(817))(502(56)(884))))(825))))(955(767(435(343(249(170(20)(367))(27(428)(907)))(913))(87(929)(328)))(74(116(441(3(877)(146))(835(74)(135)))(829(932(263)(64))(944)))(639(794)(613(27)(815(728)(666))))))(361(184(365)(996(632(20)(69(13)(949)))(922(489(471)(348))(866(337)(627)))))(425(180(438(219)(566))(414(66(811)(674))(397)))(894(551(529(603)(462))(821(710)(544)))(900(698)(43(356)(687))))))))(321(377(200(215)(144))(784(301)(350(349)(100(725(438(366)(154))(839))(866(197(390)(902))(564))))))(729(883(737)(490(409)(118)))(366(420)(444(311(936(629(348)(205))(256(52)(904)))(461(616(47)(111))(471)))(347)))))))(460(721(848(335)(198(972(362)(934))(484(157)(656))))(431(351)(808)))(211(597(996(486(888)(429(937(139)(372(951)(951)))(500(525(954(527)(733))(888(383)(247)))(849(662)(900(941)(344))))))(903))(664))(681(250(557(681(886(694)(57(99)(660(972)(981))))(755(453(786(263)(257))(666))(818)))(62))(36(690)(721)))(27(598(478)(739))(62(968(284(954(699(592)(703))(654(816)(279)))(791))(238))(909))))))) +(406(829(52(802(122(453)(306(227)(255(601(917(640(648)(92))(878))(878))(163(343)(710)))))(830(642(812(899(875(418)(308(739)(436)))(3(186(176)(964))(937)))(829))(893(199(62)(92(388(999)(153))(114(282)(164))))(664)))(186(897(306(926)(268(369(203)(793))(454(691)(749))))(986(702(875)(414(738)(868)))(112(427(61)(334))(587))))(480(534(307(401(489)(415))(641))(37))(743(148(491)(646(38)(947)))(267(889(91)(82))(421)))))))(316))(219(235(770(183)(525(870)(447)))(134(190(796)(215))(887)))(149)))(129(934(774(646(189(430)(181(746)(163)))(750(966(411(761)(48))(151(678(459)(898(200)(87)))(122(144(821)(563))(197))))(663(710)(455(990(778(924)(343))(141(528)(67)))(810(76(888)(887))(776(111)(724)))))))(236(294(494(515(366(793(506)(851))(977(319)(577)))(394))(542))(477(15(133(492(969)(554))(313))(543(367(969)(279))(719(658)(617))))(621(0(49)(845(422)(441)))(153))))(33(115(859(18)(642(274)(48(538)(237))))(628(598)(158(745(461)(599))(696))))(650))))(876(406(931(501(274)(32(370(850(399)(724))(431(810)(376)))(441(103(918)(580))(627(259)(688)))))(444(74(643)(577(2)(799)))(572(71)(27))))(971))(856(83(110)(838(69(804)(94))(897)))(582(322(364(665)(671))(849))(364(840(485(840(185)(242))(801))(231(965(857)(670))(475(888)(381))))(961(822(762(764)(838))(519(723)(402)))(634(434(39)(742))(43(84)(110)))))))))(289(571(177(274)(823))(984(118(921)(884(408(38)(685(48(172)(393))(571(64)(434))))(47(310)(237))))(484(693(207(487(582(867)(93))(855))(56))(755))(934(665(364(600)(852(620)(625)))(393(203(734)(525))(935(470)(656))))(872)))))(899)))) +(219(539(56(513(197(904(65)(576))(252(473)(757(720(869)(574))(908))))(69))(901(115(307(671(429)(897(919)(326)))(91(452(891)(898))(993(179)(950))))(835(925(586)(838(88)(934)))(419(965)(643(70)(83)))))(247(658(866)(281(36(257)(978))(865(753)(27))))(990(262(853)(17(294)(917)))(651(866(365)(998))(419(249)(595)))))))(237(822)(470(394(606)(886(579(243(296)(255))(579))(956)))(953))))(344(508(343(515)(792(283(647(124)(611))(81(548(85)(194))(837(938)(785))))(477(265)(185(499(232)(585))(459(419)(215))))))(156(242)(966)))(117(513(107(798(603(207(759)(129))(120(650)(279)))(85(402)(907)))(911(45(208(960)(14))(732(891)(220)))(927)))(798(240(980(325)(434(223)(205)))(227(813(595)(354))(983(498)(782))))(226(51)(437(873)(255(959)(310))))))(469(545)(172(618(273)(466(808)(205(328)(755))))(835(124(286)(419))(243(742(831)(801))(417(10)(860))))))))) +(869(433(663(632(826(438)(568(22(292(183)(384))(135))(717)))(10))(618(60(291(623)(46(243(208)(665))(298)))(27(25)(563)))(493)))(956(20)(384(720(804(50)(802(214(817)(561))(865(895)(517))))(399(971(715)(872(417)(2)))(902)))(484(11(86)(130))(768(583(95(377)(465))(590))(357(943)(463)))))))(907(32(120(412(227)(138(893)(15(728(436)(300))(940(140)(668)))))(718(401)(777(106(120(940)(508))(912(753)(223)))(698(936(150)(742))(297(993)(701))))))(448(41)(357)))(742(246)(657(697(510(239(289(879)(456))(474))(631(971(970)(958))(733)))(541(449)(736(328(283)(394))(482(293)(788)))))(611(630(206)(713(999)(695(948)(401))))(723(827(919(584)(541))(286(985)(797)))(179))))))) +(784(843(954(100(546(420(21(286)(257))(488(49)(207)))(194))(523(869)(748(106(373)(657))(781))))(599))(948(961(332(105(159(884)(174))(985(759)(407)))(857(329(678)(33))(161(410)(716))))(972))(145(79(73(60)(945))(155(255)(123(518)(103))))(459))))(888(601(356(219)(59))(110(563)(102)))(983(826(727(979(862(776)(148))(807(663)(469)))(447))(926(152(613)(31))(255)))(842(662(965(401)(20(973)(888)))(667(149(774)(844))(519(332)(99))))(142(92(142(860)(526))(657(458)(557)))(128(591)(364(687)(943)))))))) +(216(85(100(562(557(730(989(657)(342))(704(985)(723)))(772(636)(203)))(655))(237(644)(917(839(676)(52(229)(412)))(486(567(128)(484))(757(531)(84))))))(16(169(545)(259))(813(970(894(29(238)(971))(313(426)(855)))(721(335)(586(609)(687))))(213(591(744(856)(18))(489))(708(355(551)(826))(210(515)(890)))))))(231(291(199(970(121(882(800)(652))(719))(953))(590(152)(229(928(200)(677))(776(211)(384)))))(902(775)(200(425)(199(543(117)(197))(762(390)(639))))))(410(953)(190(230)(310(141(534(283)(702))(760(647)(359)))(872)))))) +(285(23(900(846(994(378)(147(430(630(890)(890))(644(855)(887)))(902(522)(846(194)(193)))))(335))(812))(851(466(612(869)(534(750(115)(22))(418)))(53(54(783(862(696)(398))(103(386)(73)))(236(776(164)(213))(293(474)(774))))(828(105)(366(357(920)(322))(732(229)(80))))))(650)))(441(287(729(153(398(761)(597(565(741)(729))(136(526)(316))))(807))(516(461)(85)))(429(561)(767(641(520)(204(833)(100)))(107(370(110)(186(872)(220)))(785(122)(422(751)(293)))))))(358(806)(312)))) +(942(681(997(799)(615(618(595(78(677)(753(948(851)(552(885)(209(355)(502))))(315)))(440(85)(111)))(223(899(616(97)(174(260)(811)))(128(311(789)(974(474(519)(80))(870(596)(899))))(697)))(503(739(263(163)(586(762)(470(342)(207))))(355(282(786(693)(933))(90(160)(36)))(234)))(275(774)(444(83(431(381)(543))(458(42)(969)))(146(2)(995)))))))(244(66)(878(398(216)(273))(300(248(743)(64(549(148)(625))(304(699(801)(993))(1(734)(863)))))(509(676(316)(622(136(828)(140))(910)))(149(551(966)(693(794)(235)))(146))))))))(505(931(116(59(337(69(232(190)(936(702(146)(584))(297)))(84))(705))(346))(990))(86(7(999(637(255)(531(966(39(657)(309))(475(946)(290)))(921(137)(207(365)(190)))))(606(510)(494)))(736))(290(231(957)(441))(973))))(947(28)(438(605(487)(720(510(521(32)(73))(452))(333(810(343)(149(90(700)(275))(846(129)(279))))(102(332(717(180)(289))(598))(90)))))(731(825(815)(958))(952(566(37)(250(464(824(982)(941))(906(821)(258)))(421(2)(426(804)(763)))))(567)))))))(860(328(737)(572(891(418(869(988)(777(759(442(243)(618(777)(555)))(743))(436)))(380(200(38)(859(681(763(339)(232))(150(19)(79)))(655(623(270)(906))(988(478)(208)))))(279(50)(725))))(922(78(713(205)(769(378)(523)))(174))(533(780(251(614)(11))(152))(817(270(639)(996(773(671)(201))(648(582)(764))))(203(902)(367(313(692)(707))(767(24)(277))))))))(271(954(460)(166))(536(496(30)(68))(795(97(212(209(114(66)(378))(592(258)(304)))(344))(651(220(176(202)(27))(132(295)(14)))(995(534(284)(640))(474))))(533(471(473(860(422)(549))(357(675)(914)))(834))(515)))))))(103(569)(42)))) +(911(832(222(261(538(20(900(227)(332))(215(547(586(585(955(900)(107))(194(855)(294)))(885))(253(966(330(142)(130))(822))(246(272(242)(618))(61))))(490)))(679(725(978)(817(118)(444)))(12(290)(448))))(38))(803))(502(222(238(520)(628))(747(496(195(669(3)(656(593(846(559)(521))(142(755)(276)))(647(714(281)(761))(401))))(989(349)(381(673)(213))))(458))(308(913)(224(940(425(347)(668(638)(917(27)(243))))(68))(358)))))(797(989(85(372(278)(645))(737(917)(640(428(980)(338(551(172)(20))(609(642)(452))))(637(113(864(299)(366))(796(935)(336)))(944)))))(607(451(525)(739(110)(489(994)(44(563)(821(983)(719))))))(606(855)(804(245(335(886(154)(154))(383))(592(308(590)(837))(231(719)(358))))(749(0(686(862)(307))(921))(402(574(110)(375))(270(102)(888))))))))(803(753(47(746)(936(620(568(701(659)(466))(98))(644(807(375)(8))(309(666)(577))))(23(263)(80))))(67(990(934(731(736(657)(98))(325(260)(8)))(679(355(718)(823))(285)))(207(625)(666(568)(913))))(329(128)(890(266)(642)))))(169(717)(534))))))(61(105(610)(577(26(410(364)(261(866(803)(429(571)(658(906(117)(752))(880))))(262(376)(836(283(189(576)(492))(331(419)(421)))(129(92(256)(684))(337))))))(332(741(627(73)(612(411(275(485)(603))(808))(63(645(972)(263))(737(613)(297)))))(867(21)(903(9(32)(965(496)(197)))(805(60(350)(584))(858(799)(314))))))(940(411(174(807(33)(854(224)(429)))(999(431(853)(91))(429(533)(958))))(161(810(672(896)(158))(592))(290)))(790))))(276(96)(983))))(548(431)(877(810)(437(939(732)(420))(208)))))) +(322(40(406(697)(653(334(763(814(289)(135))(293))(102))(58(294(533(727)(347))(712(881)(953)))(257))))(161(385(597(437)(342(580)(748(296)(560))))(165(522(366(863)(552))(77))(423)))(485(11)(515(970(778)(931(923)(111)))(257(524)(176))))))(480(14(765(513(988(88(236)(387))(349))(810))(570(515(962(395)(197))(888(642)(66)))(718(438(816)(561))(738(884)(490)))))(687(687(230(953(84)(526))(925))(520))(918(543(19(850)(226))(222(388)(723)))(294))))(440(758(576(807(696(75)(573))(791))(187(888(598)(934))(166(545)(284))))(528))(144(666)(895(586)(669(853(875)(600))(495))))))) +(367(144(971(360(303)(884(12(481(748)(36(196(29)(545(549)(407)))(850(529)(425(628)(291)))))(449(386(428)(545(75(267)(378))(924(207)(683))))(994(865(72)(701(333)(46)))(520(229(399)(545))(633(893)(317))))))(367(808)(317(742(273(711(569)(733))(529))(54(164(505)(707))(206(745)(449))))(159)))))(250(722(335(395)(251(297(544(918)(929))(787(405)(648(520)(132))))(834)))(774(534(549(96(738(766)(586))(825))(768(160(984)(680))(931(793)(235))))(506))(94(802(446(93(799)(359))(891(916)(806)))(597(257(188)(940))(951(613)(750))))(687(878(384)(705(235)(812)))(312(195(379)(196))(131))))))(189(829(353(126(193)(852))(625(675)(160(584(174)(616))(612(752)(848)))))(252))(103(288(752(108(38(630)(212))(539(382)(751)))(99(936(569)(271))(262)))(185(844(118(411)(700))(217))(247(734)(6(253)(650)))))(821(829(197(370(390)(887))(386))(480(249(149)(77))(127(213)(385))))(449(370(217(892)(452))(368(65)(677)))(2(865(809)(643))(439))))))))(353(478(506(614(438(646(142(675)(959(422)(194)))(482(353(795)(660))(486(842)(622))))(400(793)(192(393)(689))))(961))(797))(175))(727)))(552(379(762)(386))(184(283(759(522(854(431(7(951(815)(410))(190))(464))(456(527(810(467)(354))(421))(619(423(947)(361))(130))))(753))(771))(144(753(15(322(754(487(589)(211))(961(34)(340)))(567(840)(712(315)(793))))(487))(730))(485(641)(83(407(730(407)(491(642)(473)))(590(125(688)(787))(347(567)(833))))(850)))))(953)))) +(320(876(21(68(322)(964(724(72(115(177)(985))(721(460)(126)))(726(73(505)(83))(32)))(48(713(749(403)(703))(313))(71(180(385)(210))(736(4)(588))))))(435(182(803(311(715(456)(552))(364(142)(273)))(600(261(195)(824))(883(275)(975))))(644(790(410(88)(651))(414))(161(897(315)(899))(646(967)(442)))))(148(559(21(168(932)(659))(889(124)(505)))(168(682(19)(613))(182)))(381(365(692(449)(764))(225(545)(204)))(979(960(380)(449))(360))))))(815(693(658)(793(649(390(14(260)(685))(370))(624))(22(8(492)(429))(715(451(556)(724))(800(294)(455))))))(377(674(221(524)(207))(329(678)(164(928(822)(934))(222(929)(590)))))(354))))(750(338(806)(482(518(943(337)(843(203(804)(965))(294(964)(156))))(791(495)(373(375(460)(228))(334(681)(163)))))(537(233(931)(501(291(249)(436))(802)))(872(649(358(954)(219))(364))(588(301)(310))))))(831(217(471(825(24(856)(286))(613(21)(450(773)(453))))(382))(100))(343(666(6(93(550)(867(622)(999)))(962(267)(454(878)(698))))(549(816(302)(317(619)(115)))(746)))(692(173(897)(632(367(662)(622))(552)))(18(211(301)(436(995)(804)))(281))))))) +(592(880(594(847(551(266)(120(574)(864(677(801)(662))(577(897)(84)))))(724))(738(983)(106(779(592)(784(141)(716(841)(504))))(848))))(434(752)(265(34(352(413(877(529)(879))(163(658)(71)))(138))(969(278(382)(300(671)(602)))(410(181(198)(767))(847))))(580(888)(2)))))(240(977(609(257(46)(855(254(59)(39))(877(646(604)(919))(839(913)(533)))))(496))(84))(786(667(55)(749(47(250)(891))(260(994(277(862)(138))(439(816)(938)))(544(481(140)(950))(374)))))(864(693(988)(676))(334(79)(959(217)(877(190(178)(276))(869(704)(124))))))))) +(294(453(659(644)(625(75(687(802(311(562(830(80)(262))(805(512)(649)))(156))(43))(122(675(428(119(24)(667))(519(704)(777)))(430(185)(56(839)(684))))(814(223(931(634)(490))(987))(719))))(220))(504)))(863(446(366)(319(140)(453)))(1(922(226(744)(260(496)(288(269(639(248)(496))(940(820)(82)))(708(501)(331(341)(558))))))(698(967(864)(386(759(225(868)(953))(381))(727)))(822)))(604(182(667)(411(35(474)(138(205(64)(783))(495)))(995(300(103)(691(101)(524)))(451))))(644(125)(760(429(615(42(754)(595))(571))(526))(486(439)(700))))))))(912(761(407)(337(999)(896(206)(656))))(151(675(400(119(784(634)(800(673)(675(541(889)(282))(883(206)(884)))))(796(372(384(424(622)(397))(279(314)(36)))(24(474)(961(942)(409))))(343(683(17)(931(75)(284)))(328(29(525)(133))(5(236)(222))))))(882(697(466(727)(844(932)(555(87)(430))))(155(424(551(219)(924))(460(117)(245)))(321)))(35(665(249(6(482)(24))(454))(319(690(802)(430))(946(78)(338))))(67(597(787(162)(675))(653))(678)))))(784))(607(636(561)(505(630)(805)))(743(256)(87)))))) +(346(966(18(883(832(888)(759(549(782(505)(828))(571(341)(645)))(886(375(950)(506))(335(875)(949)))))(22))(357(44)(553(510(856)(488))(587(830(736(408)(864))(114))(864(354(635)(747))(667(774)(211)))))))(725(969)(166(970)(702(747(226)(340(830(371)(296))(496)))(139(765(688)(910(574)(298)))(739(830(817)(798))(809(359)(500))))))))(125(428(389(987(169)(738(678(422(414)(999))(941(852)(303)))(108(942(281)(277))(773))))(401(999)(559)))(655))(73(471(450(836)(18(253(124)(399(105)(736)))(532(510(243)(699))(575(444)(66)))))(834(784(2(345)(22(469)(6)))(752))(258(692(398)(311))(507))))(952)))) +(667(914(684(859)(730(220)(948)))(910(271)(191(644)(433))))(519(915(45(762(253)(94(314)(576)))(652(233)(73(916(511(682)(135(648)(428)))(598))(744(555)(28(516)(19(69(838(575)(40))(792(657)(600)))(210)))))))(998(729(308(520(698)(442(905(398(117(361)(809))(161))(119))(975(273(576)(919))(432(65)(95(264)(770))))))(560))(717(337)(761(491)(366(96(662(754(619)(579))(144))(679(597(724)(594))(876(522)(288))))(436(688(711(115)(861))(134(708)(170)))(533(546)(821(870)(672))))))))(745(109)(633(895(860(614)(735(256(112)(764))(796(237(390)(368))(917(834)(250)))))(184))(844(887)(346(789)(717(854(173(45)(943))(150))(941))))))))(791(669(799(419(874)(732(362)(225)))(981))(185(844(185(474(192(741)(722))(650(981(130(196)(307))(377))(774)))(33(848)(507(532)(33(328(407)(276))(153)))))(809))(189(393)(528(180(328(571(791)(36(154)(896)))(212(632)(153)))(167))(594(184(440(766(727)(683))(508(810)(675)))(966(537(188)(977))(888(65)(80))))(60(618(105)(290(312)(996)))(441)))))))(35(516)(883(805(920(240(382(684)(762(87(743)(5))(936(19)(190))))(697(321(41)(929(905)(934)))(776(919(957)(276))(267(900)(350)))))(136(431(822(272)(708(426)(653)))(592(743(778)(378))(758(689)(302))))(125(816(308)(332(18)(515)))(263))))(775))(501)))))) +(261(541(634(380)(941(594(171(633)(277(387(550)(52))(443(391)(261))))(510(608)(269)))(349)))(835(610(279(127(977(650(378)(442))(75(496)(891)))(298(95)(268(78)(687))))(403(883(529(346)(934))(497(487)(782)))(119(67)(868))))(890(783(160(620)(450(284)(239)))(16(636(194)(139))(207(535)(599))))(699(188)(901(570(774)(770))(554(144)(555))))))(457)))(701(605(235)(856(681(935(763(941(904)(584))(909))(68(409(832)(111))(823(860)(779))))(516))(83(370(831(471(906)(294))(788(673)(824)))(662(772(59)(624))(825(641)(135))))(762(131(644(280)(83))(603(328)(626)))(153(719(667)(451))(770(422)(245)))))))(984(912)(367(540(428(262(926)(65(505)(442)))(955(833(52)(62))(88(720)(865))))(718(442(65(310)(255))(418))(765(179(745)(43))(329(2)(667)))))(118(780(145(38(577)(460))(476))(281(606(957)(833))(984(262)(581))))(492(40(797(343)(98))(146(513)(642)))(577(730(740)(205))(725(997)(546))))))))) +(410(55(51(490(832)(240(429(150)(916(745(204(691)(932))(548(499)(124)))(155)))(90(638(720)(837(827)(600(792)(321))))(603))))(362))(540(88)(459(935(926)(791(128(868(480(402)(255))(51))(478(753(309)(195))(109)))(423(976(621(769)(842))(94))(875(230(42)(772))(483(706)(492))))))(48))))(634(200(825(804(990(978(896)(979(258)(380(380)(498))))(485(54(314)(410))(470)))(686(381(689)(608(937)(192(134)(591))))(952(363(936(169)(486))(771(251)(16)))(122(849(49)(931))(892(996)(97))))))(749(55(497(839)(774(27(648)(343))(46(53)(730))))(711))(569)))(20(358(833(164(857(612(578)(598))(523(440)(769)))(363))(398(111(719(394)(271))(703(912)(463)))(518)))(215(108(467(567(744)(829))(727(77)(723)))(788(57(741)(186))(226(774)(484))))(946(361)(966(29)(29(589)(534))))))(586(238(482(422(894)(261))(315(435(155)(578))(221(864)(622))))(429(398)(255(468(36)(989))(988(560)(926)))))(534))))(729(258(693(145(707(319(674(921)(194))(944(407)(268)))(837(131)(243(616)(881))))(107(899)(348(596(356)(108))(81(131)(66)))))(683))(996))(111(846)(582))))) +(99(760(785(571(577)(217(137(82)(937(453(48(930(388)(227(302)(687)))(848(99(689)(298))(253(856)(179))))(573(644)(695(244)(892))))(838(618(932(807)(896))(107(379)(228)))(367(692)(359(954(973)(794))(890))))))(329(159(633)(654(342(832(930(670)(194))(743))(641(418)(787)))(170(866(94(307)(173))(924(592)(277)))(82(22(460)(239))(333(965)(726))))))(921(995(895(836(212(176)(801))(637))(206(427(476)(738))(330(984)(470))))(647(837(313(892)(182))(524(176)(613)))(265(258(549)(482))(962(846)(519)))))(145(241(290(130(857)(538))(871(325)(7)))(680(140(205)(38))(97(381)(898))))(460(352)(601)))))))(277(857)(137(476(325(243(156(228(916(764)(602))(968(393)(220)))(805))(362))(875(947)(272(350(984(815)(762))(971(593)(691)))(272))))(799(595)(839)))(422))))(665(894(461)(544(880(888(719)(631(215)(829(714(488(129)(941))(628(169)(722)))(830))))(601(934(958(479)(614))(570(988(223)(503(104)(479)))(522)))(575(580(324(873)(158(81)(855)))(549))(701(113(767(545)(454))(164(282)(49)))(807)))))(238)))(91)))(115(46(641)(825(196(418(307(173(550)(152))(400(48(954(18)(965(485)(576)))(271(355(334)(549))(177)))(335(435)(472(94(932)(155))(215(523)(230))))))(473))(885))(635(365(341(835)(774(707(499)(144(757(691)(704))(534(106)(815))))(912(59(101)(301))(636(144(882)(103))(385(10)(687))))))(868))(516(395(321(472(104)(716(639(4)(497))(993)))(838(114)(131(217(588)(944))(780(889)(449)))))(471(927(76(505(729)(58))(929))(749(748(566)(729))(647(758)(285))))(300)))(733)))))(877(978(308(818(493(884(803(97)(62(395)(940)))(312))(461(526(77(520(48)(590))(906))(456(365(901)(264))(65)))(968)))(273(659(782(281(152(65)(953))(944(772)(75)))(976(55(925)(508))(526)))(827(134(673(309)(518))(696(629)(905)))(251)))(307)))(263))(471(447)(5(97(308)(729))(282))))(966(890)(86(977)(32)))))) +(252(556(259(58)(553))(252(553)(232(286(10(126)(654))(949(515(557)(242))(697(346)(638))))(430(704(806(516)(222))(70))(910(287)(865(848)(419)))))))(687(3(95(405)(888))(14(14(223(573)(551(689)(5)))(542(702)(22(211)(237))))(723)))(262(266(274(700(62)(493(640)(496)))(528(397(40)(245))(954)))(87(474)(427(813(916)(650))(916(841)(575)))))(750)))) +(734(442(130(617(578(626)(752(449(907)(888))(610(118)(316))))(538(231(597)(897(537)(299)))(731(776)(41(672)(511)))))(13))(398(303(972(266)(556(660(351)(638))(458)))(767(887)(353(133(152)(801))(997(856)(957)))))(6(427)(351(902(788)(27(105)(580)))(908(953(689)(465))(312))))))(517(963(20(792(287(566(423)(378))(73(727)(642)))(98(685(171)(69))(923(661)(989))))(436(355)(272)))(744))(91(667(164)(665))(473(70(610(431(127)(902))(84(177)(801)))(115(877(472)(927))(187)))(891(48(694(322)(821))(715))(216(509(513)(17))(896(619)(122)))))))) +(655(558(864(315(611(210)(547))(76(24)(409)))(596))(60(797(274(702(902)(307(800(642)(275))(494(625)(30))))(726))(949))(542)))(564(203(155(11(306)(992))(946(509(813)(645))(918(350(866)(815(357)(867)))(234(443(452)(253))(589(587)(407))))))(148(82(829)(878(61(110)(241))(763)))(198)))(485(111(829)(706(36(448(25)(781(963)(304)))(643(514(128)(709))(791(500)(161))))(460(202(250)(96(206)(405)))(736(65)(553(868)(296))))))(447)))) +(728(760(302(553(753(145)(709(773(337(932)(761))(456(991(317)(912(929(589)(132))(136(893)(192))))(511)))(935(817)(493(546(950)(37(841(811)(936))(355)))(356)))))(849))(991(398(963(324(547(382)(655(704(696(471)(166))(483(795)(146)))(517(462)(665(324)(880)))))(456))(628))(659(7)(669(347(921(653)(660(509(183)(903))(55(697)(251))))(575(318)(830)))(332))))(372(932(994(810(431)(683(137(700)(770(147)(52)))(946)))(336(580(43(954(517)(29))(568))(318(185(677)(107))(586(318)(926))))(108(412(802(33)(128))(173))(834))))(764))(603(60(877(248(613(571(833)(126))(357(290)(333)))(617))(671(384(12(39)(452))(752(137)(561)))(181(288(684)(929))(730(693)(961)))))(866(22(883(312(867)(159))(114))(901(37(956)(619))(190(436)(152))))(504(620)(538(686)(417(31)(758))))))(864)))))(891(369(935(818(949(141(258)(82(98)(99(385)(157(860)(651)))))(997(677(205(959(35)(78))(145(919)(470)))(121))(465)))(946(26(815)(607(298(971(615)(851))(685(892)(541)))(827(956(253)(784))(833(657)(389)))))(352(966(314(53(346)(468))(141(957)(208)))(170(32(873)(985))(511)))(94))))(780(353(609(87(365)(421(103(836)(15))(894(665)(214))))(171(201(441)(682(857)(312)))(259(291)(668(176)(592)))))(269(244(927(672(642)(333))(32))(877))(562(325(62)(875(68)(796)))(530(933)(259(756)(690))))))(595(895(456(543(919(226)(578))(890(158)(379)))(117))(907))(308(202(34(150(807)(241))(590(100)(877)))(980(137)(955(826)(732))))(106(650(929(326)(631))(780))(940))))))(19(1)(998(893(516(140(24(28(900)(149))(926(387)(913)))(484))(106))(789))(689(953)(679)))))(141(718)(500(603(801)(285))(781)))))(376(250(810)(68))(659(99(184)(776(822(553(548(345(181)(571(169(224)(644))(790(575)(939))))(62))(598))(718(283(711(929(678)(519))(628))(762(146(421)(514(289)(602)))(347(135(126)(683))(764(653)(588)))))(804(486(872(523(70)(247))(693))(230(33)(767(629)(956))))(430(48)(13)))))(59(717)(249(211(94(581(26)(424(568)(890)))(162(980(738)(64))(892(563)(879))))(10(623(450(87)(53))(836(981)(705)))(375(658(481)(49))(887))))(798)))))(617(178(728(646)(543(454(95(131)(377(152(406)(54))(654(155)(835))))(787(731(61)(785(354)(215)))(100(10)(692))))(399(569(790(330(351)(218))(868))(681(622)(66)))(443(993(524)(876(741)(557)))(59)))))(388(680(988)(167))(255(761(181(195(250)(903(457)(290)))(374))(352(194(911(972)(331))(2(746)(139)))(914(750(312)(991))(594(744)(773)))))(380))))(730(867)(241(745(933(904(916)(616(398(0)(95))(10(158)(642))))(816))(120(267(931)(466(821(528)(222))(567(376)(668))))(200)))(811(285(1(894)(719(972(379)(650))(422(994)(10))))(239))(120(259)(748(61(521(426)(755))(344(181)(600)))(640)))))))))) +(502(740(856(332(132(113)(964(502(925)(22))(195(997)(705))))(771))(385))(107(790(771(677)(639))(663))(861)))(728(986(362(559(524(720)(458(853)(589)))(450))(21))(993(230(581)(157(206(957)(270))(190(686)(205))))(327(374(769(571)(776))(143))(754(192(215)(393))(827(307)(951))))))(159(731)(924)))) +(79(999(151(586)(56))(631(606)(400(276(881)(748))(952(641(701)(249(281(821)(661))(554)))(881)))))(829(963(946(373)(604(377(805)(372))(828(243(665)(373(342(72)(998))(979(68)(247))))(938(98(802(105)(597))(570))(550)))))(667(468(442)(626(444)(580(337)(553))))(830(597)(151))))(898(58(404(235(325(888(251(574)(961))(687))(28(845(313)(977))(297(638)(240))))(868))(712(410(699)(447))(577(462(786)(870))(423))))(206(437(129(905(711(407)(298))(14))(635(201)(627(226)(135))))(781(646(384)(263))(590(454(77)(235))(145))))(996)))(6)))) +(896(250(11(658(389(504)(159(576(920)(836))(608)))(617(31(997(648)(647))(392(859)(846)))(855(513)(326))))(321(715(446)(929(908)(839(815)(337))))(590(338)(743(7)(446(28)(385))))))(439(838(14(736(256(177)(398))(866(653)(23)))(395))(953))(51)))(229(970(93(380)(999(251(339)(711(915)(300)))(428(472)(810))))(379(392(551)(86(700(593)(546))(788(897)(477))))(385)))(253(98(648)(717(642(196(749)(213))(736(395)(250)))(814(44(223)(990))(249(894)(338)))))(516)))) +(29(594(488(63)(746))(997(110(76(330)(579))(730(965(779(201(95)(14))(80(551)(760)))(577(329)(780)))(616)))(505(784(610(481)(452))(472(533(782)(961))(777)))(623(301(677)(803))(706(261(703)(718))(303(503)(556(618)(747))))))))(612(840(65(588(991(385)(203))(848))(571(301(224(260(518)(321))(222(237)(881)))(763(41(927)(59))(826(16)(249))))(816(209(912(74)(57))(18(343)(378)))(399(694(784)(523))(525(825)(903))))))(901))(729(749(4(329(515(382(80)(183))(25))(495(884(167)(284))(413(151)(864))))(477(603(144)(188(631)(341)))(790(897(334)(473))(1(163)(818)))))(500(299(749(922(601)(775))(751(832)(830)))(405(83)(222)))(33(167(664(340)(920))(163(824)(126)))(581(709)(861(373)(559))))))(568(94(697(229(785(497)(393))(214))(704))(121(969(28(444)(583))(870(254)(618)))(685(159)(284))))(194(22)(26(996(70(122)(769))(987))(464(598(601)(319))(192(912)(166))))))))) +(662(884(946(656(795(367)(60(626(56(704(241(740)(45))(465(122)(207)))(260(708(589)(916))(245)))(593(465(322(753)(630))(448(285)(451)))(481(321(78)(746))(413(145)(477)))))(602(942(217(176(456)(666))(2(503)(253)))(670))(948(510)(587(432(335)(533))(451(743)(224)))))))(376))(40))(868(453(680(795(788(284)(422(1(109)(805(750)(298)))(427)))(674(350(364(613(881)(33))(629))(812(891(135)(886))(263(625)(482))))(740(482)(520(591(821)(224))(774(670)(78))))))(379(101(743(867(548)(429(315)(984)))(267))(767))(827(724(212(516)(8))(229(980)(260(239)(229))))(383(883)(888(12(479)(527))(666))))))(751))(716(573(997(926)(67))(554(461)(3(12(974(840(997)(788))(907))(363))(604(787)(435)))))(550(958(475(968(866)(704(702(357)(59))(313)))(51(355)(119(352(669)(423))(673(389)(56)))))(255(484(316(545(468)(112))(501(649)(513)))(83(33)(542)))(754(343)(950(390)(393(659)(163))))))(736)))))(771(765(521(11)(16(437(352(570(461(608(433)(476))(907(805)(167)))(674))(453))(959(389(861(22)(685(23)(76)))(807(955)(438(32)(133))))(401)))(229(919(152(942)(673(393(391)(330))(213)))(274(408(447(491)(581))(324(26)(526)))(425(88(315)(420))(427))))(838(613(728(584(122)(435))(693(621)(393)))(809))(750(309)(332(772(922)(127))(436(238)(229))))))))(50(350)(312(609)(925(389(781(451(935(311)(368))(377(896)(777)))(811(641)(66)))(437(828)(420(48)(42(853)(938)))))(337(787)(288(487(313)(544))(68(394)(685))))))))(817(496(397(594(930)(119(720(49(785(418)(298))(826(508)(605)))(912(444(16)(411))(227)))(304)))(970))(14(176)(959)))(145(81)(161(895(378)(5(58(839(10)(508(542)(227)))(85))(261)))(616(861)(958(245(934(570(895)(102))(721(125)(311)))(631(544(51)(699))(191(290)(948))))(765(287(411)(202(241)(876)))(62(104)(238(654)(993))))))))))) +(801(628(263(35(303(401(417(942(141)(222))(426(527)(124)))(836(913(853)(773))(688(908)(220))))(430))(306(572(505)(183(888)(880)))(208(92(154)(137(0)(600)))(736(206(888)(450))(326(789)(114))))))(735))(304(942(393(892(984)(507(588(516)(99))(734(784)(999))))(925(446(612(752)(353))(339(730)(676)))(89(231)(685(461)(609)))))(828(268)(76(686(557(499)(177))(77(917)(18)))(266(24(934)(910))(837(226)(895))))))(948(666)(748(198(100)(994(592(637)(434))(253(858)(804))))(433(532(357(83)(145))(635(371)(995)))(144))))))(137(597(929(62(422(717(816)(301(638)(25)))(123))(132))(404))(843))(471(146)(536(896(822)(959(769(172)(284))(853)))(156))))) +(704(294(634(743(365(112(182)(488))(675(586)(822(968)(278))))(809(481(679(389)(765(73(810(782)(989))(286(445)(390)))(51(327(509)(350))(208))))(854(85(760(375(915)(954))(626(168)(243)))(61(83(786)(785))(709)))(73)))(133)))(178))(318(177(501)(316(621(364(447(980)(24))(546))(383(799(854(790(130)(963))(775(657)(30)))(30(222)(614(789)(874))))(630)))(371(710)(792(144(883(273(497)(162))(257(992)(463)))(767(614(324)(371))(566(43)(219))))(992(649(282(900)(797))(844))(462(53)(617(527)(139))))))))(698(272)(177))))(304(197(683(442(533(947(664)(253(212(679(858)(74))(158))(269)))(862(678(177(631(90)(180))(956(748)(755)))(322(373)(451(838)(371))))(792(851(715(302)(179))(609(732)(161)))(213(524(563)(746))(710)))))(264(106(251)(130))(774(285(24)(55(685)(618(783)(621))))(40(329)(244)))))(661(219(615)(808(314)(899(749(933(595)(432))(855(799)(882)))(706(231)(345(614)(238))))))(520)))(986))(997(730)(806(911(495)(292(255(29(379)(243))(473(319(740(719)(49))(697(820)(419)))(173(526)(251(513)(817)))))(13(284(83(602(470)(421))(752(432)(0)))(276(495(536)(675))(150(124)(534))))(510(857(502(721)(476))(649))(922(784)(440(721)(991)))))))(354(938(736(750(196(804(315)(124))(203(502)(810)))(838(416)(346)))(627(401(618(717)(468))(213(703)(163)))(637(101)(428(622)(153)))))(284(972(11(917(902)(317))(561(50)(289)))(597(663(742)(687))(772(688)(32))))(563(618)(38(9(236)(225))(905)))))(22)))))) +(503(796(915(843(514)(392(618(218)(289(733(709)(229))(408)))(206(25(93(680)(891))(391(268)(964)))(66))))(265(889)(157)))(808(302)(727)))(824(403(31(16(314)(465(474(604(6)(414))(294(246)(728)))(718(326)(51))))(832(910(174)(181(38(750)(199))(762(760)(980))))(864(229)(333(493)(391)))))(960(798)(336(437(587(299(294)(41))(349(227)(906)))(371(517(965)(226))(449(500)(51))))(807))))(544(194)(642(620(325(743(829(151)(700))(802(619)(173)))(345(689)(572(540)(28))))(290(675(515(309)(124))(330(847)(385)))(626)))(730(826)(413(797(807)(170(185)(885)))(217(851)(531(548)(493))))))))) +(840(452(552(6(903(632(381)(113(399)(353)))(180(504(121)(825))(605(57)(407))))(840(651)(1(387(358)(755))(520(647)(962)))))(837))(356(759(533(731(160(228)(548))(522(225)(461)))(379(156(667)(777))(438(200)(572))))(211(19(184)(863(928)(237)))(326(221(829)(867))(765(709)(743)))))(446)))(994(332(763(683)(957(821)(313)))(223(362(645(270)(921(232)(281)))(926))(133)))(957(736(851(236(848)(741(706)(90)))(378))(405(989(696)(884(995)(991)))(179(805(420)(464))(49(627)(88)))))(362)))) +(179(734(868(218(212(776(704(477)(639))(237(325)(127)))(821))(449(449(502)(362(680)(613)))(998)))(170))(648(331(736(47(325)(215))(375(134(607)(384))(273)))(517(570(665(93)(752))(826(230)(480)))(814(952(960)(644))(632(139)(675)))))(797(918(761(658(273)(628))(993(585)(874)))(307))(862(680)(138(596)(705))))))(904(144(251(620(467(185(431)(795))(668(398)(398)))(134(929(539)(451))(236(724)(555))))(989(824(562(471)(601))(101(210)(14)))(444(301)(755(127)(384)))))(684(524(676(95(460)(605))(323(717)(269)))(99(243(31)(875))(634)))(977(738(92(828)(581))(478))(340))))(534(584(838(641(516(405)(334))(220))(423(913(140)(593))(271(269)(499))))(594(534(646(475)(358))(252(94)(385)))(697(771)(542(353)(108)))))(744(867(396(225(788)(433))(933(406)(416)))(16(933)(52(78)(290))))(327))))) +(568(749(107(784(197(580(979(980(336)(392))(597(80(101)(315(188)(179)))(941(482)(821(112)(546)))))(745(316(209)(308(582(665)(745))(253(177)(756))))(797(487(403(234)(640))(190))(296))))(632))(537(879(442(236)(58(303(947(684)(262))(704(31)(990)))(543)))(269(276)(632(578(127(319)(409))(113(311)(284)))(964(572(811)(170))(573(932)(446))))))(305(789(70(96(401(592)(151))(76(832)(759)))(352(663(7)(144))(768)))(14(34(457(618)(808))(75(956)(915)))(178(370(189)(409))(938(947)(920)))))(258))))(642(876)(902(735)(710(761(318(236(504(974)(113))(222(96)(616)))(982(577(761)(920))(940(420)(725))))(622(863(578)(291(806)(307)))(527(711)(978(860)(220)))))(191(228(758(745(221)(774))(57(85)(400)))(40))(509(979(28(93)(60))(868))(26)))))))(650(237)(47(502(956(563(630)(48))(30(764(652(327)(282(412)(817)))(456(96(400)(395))(685)))(608(732)(96(659(268)(696))(329)))))(499))(121(392(495(681(759(330(214)(297))(42(826)(18)))(462(939(25)(442))(13(879)(859))))(640(751)(442(855(234)(468))(512(474)(408)))))(51(282)(68)))(730)))))(822(176(180)(691(521(676(830)(81))(897(889(898(10(691(236)(482))(468(304)(218)))(517))(725))(87)))(833(84(456(79(656(101)(293(433)(880)))(0(91(915)(280))(118)))(213(696(816(385)(582))(955(460)(622)))(298(667(868)(590))(859(984)(301)))))(932(621(69(543(89)(959))(678))(932(995)(367(585)(912))))(243(768)(970(890(397)(50))(175(463)(858))))))(870(987(902)(793(245(598)(181(556)(741)))(794(566(606)(23))(144(974)(113)))))(616)))))(138(294)(817(682(23(686)(621(57(469(0(165)(458))(939))(744))(679(359)(520))))(951(20)(720(919(382(346(227)(563))(581(75)(737)))(526(492)(988(338)(481))))(173(801(534(421)(997))(908(513)(767)))(85(837(577)(754))(705(300)(246)))))))(622(93)(794)))))) +(266(36(732(651(967(999(294(444)(272(901(19)(737))(594(832(563)(42(679)(909)))(148(118(773)(289))(526)))))(414(771)(927(577)(635(596(874)(466(507)(186)))(346(474(418)(696))(971))))))(260(379)(173(984(25(366(498(711)(978))(364(704)(854)))(762(23(32)(186))(917(149)(719))))(72(512(995(492)(156))(14(495)(633)))(998)))(605))))(495(699(164(979(526(591(250(153)(373))(546))(846))(426(550(788)(463(224)(467)))(969(398(940)(166))(613))))(36(335)(595)))(587(490(34(161(73(888)(542))(470))(130(181(193)(24))(161(893)(422))))(752(518(71)(23(578)(863)))(533)))(122)))(296(278)(615(942(85)(441(16)(697(318(947)(602))(831(979)(926)))))(261(121)(291))))))(819(241(391(454)(879(5)(324(237(914(760)(805(885)(486)))(980(85(457)(481))(938)))(48(765(928)(240(394)(904)))(266(783(956)(362))(685(376)(530)))))))(683(640(334(300(772(941(271)(847))(415(314)(412)))(263))(843(180)(911)))(540))(883(879)(819(430(396(526)(335))(846(605)(538(620)(83))))(713)))))(33(614(141(577)(590(375(538)(974(784(190)(123))(995(274)(790))))(650(631(541(891)(107))(8(885)(327)))(539(508(933)(962))(217(890)(312))))))(375(520)(6)))(871(99(711(314)(153))(296(390(479(924(23)(284))(148(766)(244)))(1(366(838)(291))(854(911)(781))))(848(436(802(268)(956))(960))(330(145)(443(353)(67))))))(586)))))(74(417)(74(376(879)(784(271(992(843(220(184(444)(568))(36))(741))(557))(150(125(825)(281(40(20)(389))(913)))(46)))(834)))(405(321(937(729)(288))(445(388)(273(256(13(792(38)(649))(661(257)(329)))(174(899(701)(264))(47(350)(452))))(251))))(534)))))(224(431(869(877(17)(95(83)(695)))(718))(276(647(181(41(120(209(119(472(305)(496))(843))(483(171(657)(179))(448)))(390))(352(671(628(805)(454(927)(952)))(210))(262(800(565(702)(260))(664(510)(486)))(317(364)(34(303)(396))))))(622(778)(546)))(279(356(613(947(910(626(806)(708))(59(769)(630)))(984))(996(1(739(449)(386))(986(917)(915)))(204(680(921)(507))(868(468)(661)))))(576(965(935(727)(26(447)(89)))(321(976)(119)))(519(877(779(687)(322))(25(993)(430)))(356(903(109)(181))(189(220)(490))))))(78(404(644(271(682(417)(470))(405(327)(430)))(265))(444))(123))))(622(691(292(881(549(561)(496(198)(654)))(744))(541(7(580)(671(313)(426(679)(687))))(735(399(351(321)(671))(82))(487(690(811)(847))(377(638)(860))))))(817))(319))))(766(841)(499)))) +(626(134(15(117(906(278(110(566(407)(722))(589(365)(624)))(369(320(87)(483))(48(751)(540))))(950))(838(545(505(280(807)(853))(205(216)(880)))(676(457)(302(892)(608))))(49(195(357(477)(32))(999(846)(699)))(257))))(286(981(205(616(990)(21(578)(527)))(545(297(93)(389))(811(516)(875))))(257(880(741(736)(861))(236(64)(430)))(823(767(687)(308))(9(748)(879)))))(487)))(297(102(157(10)(105(433(254)(90(304)(472)))(687(456)(72(32)(180)))))(378(25(328(109(616)(959))(443))(918(732(581)(984))(66)))(517(655)(110))))(977(16(516(631(217(501)(201))(976))(985(866(571)(698))(176(351)(764))))(336))(93(759)(623)))))(718(274(97)(88(626)(107)))(165(127(78)(167(282(76(584)(294))(906(993(55)(526))(840)))(182(671)(753(535)(946(22)(895))))))(340(190(669(411(464(848)(239))(647(706)(187)))(772(41(64)(756))(849(239)(747))))(840))(224(614(36(233)(326(721)(879)))(344(62(284)(203))(614)))(504(247)(386(995)(110(167)(203))))))))) +(594(992(560(64(251(42(7)(36(23(104)(603))(433)))(369(715)(178(37(261)(975))(837))))(286(953(606(312(5)(284))(957(26)(138)))(808))(321)))(759(516(658)(464(898)(363)))(22(23(446(268)(784(31)(954)))(184(830(267)(797))(857(194)(426))))(670(474)(140(636(726)(787))(333))))))(924(299)(704(447)(316(215)(866(642(828(382)(151))(562(66)(570)))(418(719)(688(575)(748))))))))(348(533(241)(860))(307(908)(199(876(317)(465(426(630(378)(349))(528(21)(912)))(599(267(847)(809))(76(10)(98)))))(441(913(175(466(268)(953))(790))(157(862(974)(809))(925(888)(863))))(504(746)(500(982)(350)))))))) +(642(19(981(379)(316(85(903(548(115(551)(876))(664))(352(794(137)(88))(772(668)(719))))(63(691(694(741)(9))(149(573)(921)))(258)))(573)))(283(776)(59(392)(955(240(754(601(272)(194))(822(217)(944)))(998(646)(219)))(342)))))(18(532(86(215(289)(413(226(484(569)(835))(922))(589(728)(0))))(480))(263))(511(11)(32(406(519)(788(221(22(940)(577))(541))(772(247(721)(991))(785(600)(751)))))(526))))) +(178(616(609(309)(215(292)(626)))(359(579(620(220(904)(225(461(859(351(80)(187))(535(511)(72)))(568(118(733)(817))(334(284)(875))))(283(862(486(210)(510))(877(137)(991)))(652(382(576)(674))(0)))))(185(665(824)(819(939(803)(937(650)(400)))(510)))(179(790(394)(622(174(417)(421))(774(689)(888))))(434(38(138)(771(360)(641)))(893(798(539)(613))(298(866)(381)))))))(559(769(524(529)(290))(57(808(141)(365(780(563)(279))(543(504)(11))))(751(904(367)(20(380)(620)))(743(705)(347)))))(886(620(908(473)(936))(170(924(569)(243(447)(569)))(161)))(575))))(933)))(942(519(24(641(38)(687(672(43(811(859(595)(531))(716(930)(414)))(622(864(164)(754))(174(308)(767))))(533(626)(429)))(829(688(634(716(391)(950))(944))(798(63(912)(955))(558(155)(26))))(878(952)(973(409)(885))))))(691))(287(836(912)(492))(627(819)(41(738(808(777(696(203)(801))(18(126)(882)))(583(433(695)(57))(430(905)(841))))(882(301)(829(425(909)(710))(903(86)(454)))))(661)))))(378(575(329(634(341(401(108(409)(918(314)(866)))(40(436)(841)))(940(409)(832)))(741(817(481)(563(464(210)(163))(19(651)(653))))(212)))(484))(396(701(600(967(812(858)(762))(753))(13(834(386(632)(272))(523))(695(400(316)(316))(748(845)(442)))))(240(7(910(636(942)(862))(582(110)(696)))(523(951)(725(782)(751))))(12(971)(390(11(650)(996))(834)))))(665(363(322(246(666)(544(356)(317)))(233(122)(245(176)(101))))(820))(809(626(933(0(570)(762))(892(180)(72)))(294(28(863)(135))(305(552)(965))))(465)))))(777(810(172(436)(847(828(385(838(836)(379))(987(692)(580)))(149))(66)))(362(474(436(581)(549))(360(347(199)(956(898)(53)))(700(299)(830(926)(525)))))(441(713)(946))))(317(42(378)(226(789(806(451(198)(859))(570(233)(468)))(508))(596(114(95)(233))(865(454)(444(252)(674))))))(940)))))) +(921(84(278(331(133)(942))(173(139(406(314(510)(656))(963(307)(503)))(370))(815(143(4)(168(123)(613)))(62))))(203(857(641(309(868(773)(697))(475(183)(97)))(316(767(256)(959))(319(475)(27))))(192(49(733(155)(755))(142(568)(654)))(841)))(572)))(914(311(813)(148))(55(545(880(480(257)(567(94)(150)))(779))(502))(731(988(21(644(298)(105))(164))(179))(676))))) +(444(439(690(270(836(864(967)(763(222)(329)))(213))(797))(257(709(12(937(555)(544))(442(236)(649)))(264(878(843)(689))(869)))(911)))(622(313(737(337(254(264)(645))(561(40)(891)))(966(742)(892(967)(14))))(979))(772(646(650(451(368)(983))(479))(25))(907(837(368(326)(446))(715))(962)))))(639(589(860)(180(72)(680(231)(120(445(607)(613))(121(840)(90))))))(160(984(669(288(898)(191))(989(572)(889(232)(867))))(301(969)(623(541(815)(624))(252(316)(879)))))(560(702(38(97(980)(394))(958))(204(583(659)(402))(39(752)(412))))(416(756(252(49)(837))(954(640)(605)))(731)))))) +(193(527(973(446(167)(603(268)(451(599(412(24(368)(885))(568))(215(647(523(393(105)(404))(354(539)(911)))(378(752(46)(581))(827)))(942(504)(154(802)(635(464)(350))))))(170(830(269)(312(857(76)(734(378)(158)))(256)))(580)))))(267(14(264(906(760(207(897(421(335)(523))(633(687)(481)))(966))(485))(918(826(914(343(962)(503))(47))(550(228)(243(944)(993))))(50(407)(608(433)(903)))))(413(651(939)(48(385(128)(583))(218(188)(900))))(920(960(589(434(464)(281))(573(542)(672)))(807(62(280)(129))(770)))(361(645)(962(403)(562(193)(894)))))))(990))(529(305(560)(623(935(36)(711))(221(322(969)(161(405(534)(603))(869(966)(249))))(185))))(497(410(689)(642))(316(749)(534(149(306)(678(935(278)(890))(155(923)(724))))(869(210)(734(511(637)(147))(220(606)(871))))))))))(866(379(198(422)(589(197(156)(569))(770(689(474(600(312(382)(477))(534))(155(84(313)(343))(890(445)(313))))(808))(879))))(435))(613(579)(120(432(14(714)(491))(868))(861(844)(93))))))(535(657(983(508(158(630)(970))(455(100)(168(676(890)(353(986(401(658)(935))(213(672)(265)))(201(472(553)(536))(476(397)(793)))))(368))))(277(418)(354(897)(779(267(762(700)(305(758(183)(611))(152(567)(653))))(680))(304(395(622(26)(425(792)(148)))(307(50(378)(212))(582)))(508))))))(993))(210(681(23(536)(811(445(152(671(22(896(856)(73))(594(538)(80)))(948(36)(842(220)(411))))(251(135(395)(86(201)(137)))(107(665(935)(305))(445(174)(915)))))(611(145(406)(713(181(558)(258))(339(736)(794))))(783(54(427(674)(640))(404))(776))))(670(422)(935(422(331(433)(24(654)(549)))(394))(669(754(656)(801(512)(248)))(666(904)(299)))))))(733(48(986(260(205)(362(950(590(896)(901))(773(142)(382)))(517(755)(766(795)(340)))))(137(690)(367(955)(680))))(868))(869(18)(666(342(804(806(339)(292))(482(232(420)(276))(764(949)(455))))(28(43(374(142)(542))(202(158)(62)))(570(811(330)(105))(304))))(375(209(464(737(669)(457))(311))(505(514)(586)))(322(338)(535(843(157)(824))(801(342)(497)))))))))(485(346)(882(801)(250(638(316(4(849)(288(241)(757)))(169))(572(308(502(254)(558(744)(699)))(972))(55)))(738(154(89(736)(997))(983(884)(448(498(885)(454))(840(187)(49)))))(276(791)(107(112(550(24)(109))(889))(199(888)(679(917)(585)))))))))))) +(150(648(364(555(790(992(428(668(860)(521))(80(317)(177)))(143(871(753)(617))(760)))(707(782(739(605)(358))(213))(293)))(888))(357(79)(486(546(774(596(984)(73))(655(494)(0)))(232))(845(626(85)(673(526)(423)))(234)))))(677(471)(157(898(135(764)(913))(684(303)(711(687)(94(465)(755)))))(416(585)(215(156)(196(964(54)(268))(227(901)(815))))))))(667(295(574(535(609(969(843(901)(978))(85(551)(696)))(467(971(263)(585))(910)))(958(64(514(956)(91))(967))(343(820(388)(733))(672(811)(411)))))(594(827(705(658(740)(415))(220(438)(821)))(372))(380)))(995(950(887(468(794)(644(81)(393)))(743(918(64)(297))(615(737)(662))))(714(646(160(22)(477))(238(595)(934)))(655(419(995)(494))(275))))(19(934(287(350(995)(526))(815(287)(700)))(657))(217(258(548(492)(234))(0(609)(129)))(623(910(407)(90))(819))))))(448(210(802)(488))(763(93(194(276(440)(39(349)(137)))(683(561)(286(765)(324))))(968(196(849(282)(451))(803(247)(949)))(201(163(554)(469))(641))))(92(687(281)(193(780)(745(44)(376))))(894(337)(547(632(400)(108))(132(564)(903))))))))) +(920(126(443(750)(378(337)(148(226)(226(407(233(152)(557))(819))(773(248(714)(832(63(210)(589))(326)))(755(739)(391(658(225)(996))(54))))))))(225(662)(943)))(241(922(95)(547(359)(326(390)(577(291(138(16(235(155)(230))(536(81)(825)))(157))(285(827(345)(560(492)(887)))(788(286(922)(519))(433(990)(977)))))(181(540(810)(899(539(9)(152))(996)))(59))))))(346(949(18(872(207(714(633(564(809)(501))(505(529)(861)))(385(406(966)(776))(669)))(601(305)(422(119(459)(789))(441(219)(293)))))(637(795)(898(96(264(220)(681))(712))(793(198(96)(100))(204(566)(668))))))(969(880(853(858(101(44)(884))(840(265)(513)))(613(841)(950(672)(254))))(972(112)(793(16(834)(984))(625(837)(139)))))(140(215)(497(868)(530(898(775)(679))(738(73)(963)))))))(159))(98)))) +(231(604(477(11(561)(237(719(224(373(84(982(340)(583))(667(433(369)(560))(235(363)(315))))(60(213(794(663)(349))(908))(483)))(586(693)(607(430)(918(800)(84(326)(310))))))(348(328)(56(59(630(828(654)(590))(66(643)(368)))(261(583(671)(999))(155(637)(482))))(87))))(824(772(472(616(71(50(753)(496))(86))(545(446(543)(639))(979(82)(272))))(884(554)(672(48(634)(128))(356(245)(564)))))(792(769(461(199)(848(82)(961)))(446))(100(830(269(451)(304))(507(966)(62)))(665(323(168)(986))(65)))))(157))))(138))(738(619)(573(543)(643(991)(565(619(81(406(655(412(923)(626))(216))(806(585(702)(793))(152(541)(302))))(51(287)(122(861)(753(806)(682)))))(490(311(724(104(311)(240))(922))(933))(847(252)(240(294(418)(495))(659)))))(915))))))(416(822(299)(343))(665(987)(599(13(713(708(986(172(697(150(510)(255))(398(176)(315)))(12(187(483)(932))(943(831)(587))))(637(361(782(613)(399))(150(234)(753)))(162(133(155)(114))(943(579)(880)))))(619))(791))(504(554(202)(118(458(940(410(597)(464))(136(640)(463)))(686))(145(360)(666))))(599(705)(912(560)(896)))))(158(107(467(649(894(872)(402(190(732)(553))(924)))(243(686(865(679)(486))(237(101)(100)))(742(607(540)(258))(353))))(829(521(372(915)(933(613)(425)))(146))(27)))(482(543)(397)))(545(979(268(356)(695(9(554(795)(609))(879(246)(567)))(388)))(829(508(635(837)(97(994)(564)))(751(634(998)(880))(6(279)(317))))(710(20(173(27)(182))(520))(935(977)(680)))))(854(990(423(1(367)(152))(503(794)(143)))(605(602(170(788)(829))(899(244)(778)))(886)))(253(195(336)(123(90)(905(734)(111))))(298))))))))) +(430(653(443(105)(232(443)(42)))(720(69)(892(555(236(236(980)(424(469)(333)))(228(829)(355(657(816)(411))(562(54)(807)))))(385(785(31)(114))(731(103(730)(486(757)(770)))(503(497(323)(219))(689(763)(502))))))(372(788(972)(269(793(698)(859))(965)))(765(418(334(663(588)(399))(244))(373(614(897)(232))(488)))(476(723)(568(426(284)(818))(739))))))))(883(715(61)(760(128)(767)))(475(210(447(99(681)(66(942(563)(806))(545(541(975)(226))(549))))(317))(742))(384)))) +(352(389(685(369)(593(172(379(229(63(402(852(181)(832))(254(856)(917)))(105(86(732)(753))(896(39)(955))))(821(464)(58(475(779)(454))(567(152)(941)))))(24(640(873(124)(53))(133))(479(444(887(776)(733))(709(892)(564)))(1(872(756)(95))(834)))))(259(140)(920)))(130(834(312)(311(211(171(919(417)(990))(845))(353(877(718)(877))(483(413)(637))))(862(258(820)(61(820)(381)))(817(15)(156(613)(245))))))(506(762)(431(479(161(815(394)(90))(255))(191(300)(327(647)(268))))(461(397(548(465)(935))(513(736)(150)))(941(700(569)(788))(440))))))))(72(26(193(891(685(428(267(187(165)(175))(296))(440(659(408)(974))(826(365)(204))))(690(309(531(559)(333))(375(21)(529)))(357)))(837(106(729)(227(684)(357(257)(340))))(683(981(240(758)(494))(184))(550(250(438)(428))(161)))))(960(717(379)(94))(116(750(873(947)(195(130)(605)))(945))(194(806(633)(487(667)(607)))(790(897)(588(472)(873)))))))(959(975(691)(515(145(896)(917(688(384)(958))(109(503)(752))))(905(139)(826(880(748)(789))(202(76)(0))))))(541(705(249)(165))(703(580(959(950(607)(756))(909(208)(648)))(337(749(550)(167))(555)))(225)))))(36(607(941(821(926)(438))(951(523)(268(878(448(300)(917))(942))(678(364)(37(438)(650))))))(286(204(978(35(726)(229(615)(151)))(94(384(482)(625))(792(621)(535))))(370(377(925)(109))(887)))(726(935)(535(20)(736)))))(140(782(755(626)(319(834(461)(547(348)(824)))(531(671(692)(45))(504(663)(858)))))(913(933(72(774)(897(82)(106)))(636(179(749)(526))(24(869)(801))))(738)))(513)))))(735(739(276(620(147(78(148)(941(336(190(475)(408))(489(902)(249)))(293(749)(522))))(232(916(498(703)(983))(408(659(533)(54))(986)))(899(272(948(829)(595))(627))(892(153)(534(339)(421))))))(887))(484))(157(328(120(516)(517(108(321(930)(883(902)(752)))(273(474(612)(204))(419(175)(199))))(756(907(195(296)(582))(309(943)(787)))(946))))(780(339(328(371(289(330)(232))(602(508)(420)))(36(271(563)(440))(593(692)(809))))(909(831(64)(961(509)(409)))(77(672(822)(750))(111(952)(397)))))(974(850(481(872(264)(975))(435(255)(791)))(786(823(696)(180))(235(636)(437))))(486))))(391(270)(732(870(810(665(338(55)(387))(20))(755(131)(876(585)(385))))(528(157(153(816)(48))(717(158)(755)))(752(804(112)(198))(208(592)(593)))))(23(368(82)(61(107)(756(603)(49))))(418))))))(822(294)(495(158(214(764(626)(426(327(657(29)(219))(668(153)(885)))(619(985(693)(923))(976(216)(261)))))(778))(932))(415(50(224)(348(688(384(893(99)(249))(188))(513(739)(173(870)(919))))(352(83)(693(815)(896(354)(706))))))(137(283)(247))))))) +(386(254(927(22)(509(232(22(538)(664(938(400(493)(687))(410(971)(401)))(12(736(513)(770))(11))))(365(24(162)(127(784)(214(340)(447))))(118(163(637(140)(487))(626(437)(361)))(357(108(100)(391))(919(193)(400))))))(851)))(635(477(784(468(473(475)(436(594(668)(40))(445(615)(760))))(934(709(987(115)(59))(7(620)(234)))(76(425(122)(219))(661(945)(169)))))(275(854(286)(434(915(845)(111))(527(627)(491))))(639)))(32))(977(157(727(959)(923(912(702(636)(512))(537(811)(622)))(509(904(619)(831))(260))))(287(102(275(472(292)(395))(277(805)(264)))(979(869(595)(842))(315(827)(425))))(12(522)(377(942)(208(418)(232))))))(923(216(403)(849(533(768(467)(926))(847))(762(82)(316))))(349)))))(133(728(783)(70(924(975(995(983(285(623)(181))(288(284)(205)))(389(131(192)(115))(303)))(75(571(828(500)(307))(467(442)(846)))(183(103(44)(647))(419(204)(180)))))(287(656(394)(990(584(693)(759))(108)))(616(883(31(854)(323))(633(589)(887)))(706(223(586)(474))(404)))))(767(472(851)(351(270(970)(82(548)(128)))(347)))(242(588(58(961)(30))(275))(737(437)(101))))))(55(266(252)(149(36(9(262(861(8)(350))(910(337)(513)))(660(900(338)(740))(291(31)(269))))(744(704)(502(842(740)(110))(193(608)(975)))))(465)))(933)))) +(437(610(409(875)(468(741(136(542)(641(978(972)(426(664(906(465)(739))(550(261)(104)))(869(712(274)(550))(600))))(256(360(910(406)(724(30)(686)))(204(673(684)(467))(35(156)(397))))(807(417)(200)))))(866(793(351(891(403(332(681)(146))(708))(679(581(501)(2))(620(9)(389))))(841(854)(533(49(300)(226))(56))))(560))(416(879(387(824)(646))(417))(728(829)(291(887(349(965)(549))(628(226)(903)))(660(76)(108(595)(26))))))))(869(484(813(138(197(497(723(641)(739))(382(670)(363)))(806(968)(260(876)(867))))(71))(259(289)(578)))(423(90(683(816(171(545)(8))(264))(134(832(310)(539))(822)))(981(621(343(431)(78))(512))(341(145(862)(487))(683))))(670(429)(461(672(27(55)(393))(263(464)(654)))(986)))))(587(103(203(68(521(39(183)(954))(779))(331))(360))(895))(145)))))(883(420(581(639(522(73(225(103(925(622)(543))(398))(771(37(469)(20))(472(215)(532))))(891(187)(640(321(387)(69))(183(881)(396)))))(833))(572))(241(918(770)(411(912(516(14(205)(586))(919(541)(543)))(420(711(813)(314))(478(747)(773))))(322)))(601(193)(740))))(531))(550(809(942(38)(608(699)(827(114)(502(937(84(725)(31))(831(275)(531)))(836(614)(350(926)(28)))))))(488(911(868)(439(53)(323(151(970(331)(29))(13(82)(708)))(198))))(489(64(489(788(202(841)(924))(564))(600))(759(515(397(941)(945))(416(419)(784)))(11(253(173)(933))(51(604)(140)))))(657(248(277(40(243)(240))(48))(696))(445(493(177(646)(120))(764(59)(261)))(590(60(733)(385))(673)))))))(518(873)(289(353(294)(939))(643(515(461(702(164(910)(857))(777(131)(576)))(299))(345(457(349(876)(544))(607(873)(413)))(330(820(875)(248))(240(185)(874)))))(959(189(164(324(304)(413))(845(154)(698)))(462(513(776)(97))(566(152)(256))))(153))))))))(331(26(671(101(994(136)(145(680)(389(813(724(102(569)(85))(62(845)(127)))(315(286)(224)))(271(845(666(416)(789))(781))(18(936(464)(742))(242(76)(233)))))))(661(597(934(335(673(493)(501))(329))(761))(464(284(212)(993(190(643)(692))(393)))(853)))(869(608)(610))))(726(895(85(494)(961(865)(140(794(507)(683(487)(963)))(560))))(230))(542(570(140)(485))(952(301(100(559(621)(388(290)(283)))(471(213(967)(503))(304(341)(153))))(710(159(875(909)(213))(356(651)(726)))(226(474)(620(923)(209)))))(259(759)(96(411(399(68)(891))(340(150)(890)))(552(472)(429(27)(647)))))))))(594(885(42(513(634)(430(722(874(930(298)(493))(888(124)(509)))(134(483)(835(42)(227))))(158)))(900))(161(138(674(39(277)(919))(642(871(81(775)(601))(850))(994)))(909(552)(846(935)(655(628)(530(932)(787))))))(437(6(237)(892(363(352)(792(667)(17)))(754(243)(11(843)(764)))))(196))))(214(749(722(480(46(129(227(682)(361))(531(95)(701)))(684(880(779)(884))(826(137)(723))))(782(809(887(419)(727))(562(767)(316)))(177(660)(164(823)(889)))))(876(269(968(957(754)(220))(273(219)(139)))(158))(304(477(638(601)(727))(280))(686))))(896(232(267(836(139)(394))(580(653)(394)))(683))(662(223(857)(491))(270(380)(909(138)(85(553)(701)))))))(943(608(326(69)(437(114(562)(724(235)(946)))(786(629(624)(64))(918(148)(632)))))(867(600)(319(894)(118(66(508)(942))(753(43)(90))))))(142)))))(227(739(957(778(958(637(604)(521(323(681)(406(536)(283)))(911(789(798)(450))(195))))(359))(393(619(663(938)(113(69(270)(947))(665(657)(558))))(964(275(959(815)(724))(568))(225)))(845(247)(425(896)(367(917)(197(475)(139)))))))(817(215)(63(528(280(459)(873(158(593)(661))(862(12)(514))))(86(412)(183)))(680(125)(834(619(769)(382(899)(273)))(484(145(633)(989))(47)))))))(817(341(233(232(104)(563(938)(365(20(387)(134))(638(424)(450)))))(720(378)(593(807)(800(390)(91(915)(987))))))(673(536(696(180)(876(861)(963)))(509(103(409(61)(341))(639(931)(187)))(134(83(615)(933))(859))))(373(61(709(612(141)(118))(982))(902(913(747)(565))(755)))(193))))(524(132(754(78)(194(785(156)(481))(769(894(732)(25))(278(826)(480)))))(511(9(301(866)(987))(976))(433(781(433(216)(797))(925(670)(128)))(868(847)(299(468)(530))))))(712(468(482(15(38(818)(333))(629(857)(979)))(132(276)(685(563)(590))))(525))(918(44(261(180)(935(329)(892)))(263))(895))))))(64(366(892(954(932(660)(664))(825(98(163(330(23)(164))(160(126)(720)))(481(529(421)(959))(285)))(161)))(883(755(139(232(241(422)(536))(653(754)(643)))(980(417)(865)))(170(65(689(240)(962))(485))(784(964(339)(788))(15))))(444(766(894(729(234)(723))(55(544)(537)))(566(493(821)(677))(77(756)(32))))(584(682)(525(173)(16(913)(125)))))))(223(303(110)(481))(893)))(67))))) +(414(317(558(596(895)(972(651(698(229(857(482(170)(799))(929(77)(890)))(368(487)(324(812)(731))))(50))(312(98)(513(678(275)(171(430)(943)))(771(685(238)(843))(29(360)(759))))))(900(511(452)(536))(15(998(352(183(828)(415))(391(488)(705)))(586))(119(793(701)(81(408)(793)))(887(614(511)(456))(441(867)(910))))))))(458))(269(641)(181(158)(956))))(526(636(343(943)(105(786(324(650)(775(780(200(819)(818))(641(389)(246)))(561(221(148)(695))(358))))(740))(98(783)(89(495(705(630(869)(426))(734))(221(731(178)(968))(623(565)(233))))(569)))))(397(787(317(462(29(57(698)(752(669)(105)))(166(14(384)(612))(714(586)(717))))(227(452)(656(504(100)(222))(191))))(271))(975(930(686)(353(784(453(288)(214))(598))(725)))(779(294)(450(264(682(360)(36))(563(867)(578)))(998(836(99)(542))(499(52)(342)))))))(624(866(501(51(58)(916(908(341)(833))(165(139)(333))))(503(278)(646(787)(668(664)(783)))))(380(643(949(529(350)(390))(753))(94(992)(151)))(181(269(301)(755(683)(307)))(719(235(710)(677))(88(345)(168))))))(735(780(245(454(701(220)(299))(520(332)(732)))(114(530(11)(477))(754(208)(652))))(469))(226(742)(169))))))(490(202(971(770(338(538)(256(195)(757(740(282)(152))(226(796)(423)))))(462(437(368)(875(243)(8)))(275)))(594))(246(152)(684)))(148)))) +(226(770(234(350(271(866(603(770)(728))(62(659)(52)))(425(685(836)(716))(515)))(965(414)(914(192(628)(92))(279))))(937(993(268(13(81)(958))(169(878)(203)))(169(911(711)(4))(370(58)(352))))(517(494(283(988)(9))(785(680)(379)))(725(298(639)(416))(50(265)(167))))))(757(921(180(97)(690(717(984)(312))(877(248)(964))))(213))(37(671(376(391(845)(557))(468(201)(491)))(392(592(31)(565))(544(171)(569))))(228(246)(799(106)(149(885)(290)))))))(181(849(630)(959))(361(824)(307)))) +(174(201(356(540)(797(158(446(853)(734(573)(265)))(326))(288(205)(579(261(162)(623))(382)))))(814(343)(862(841)(681))))(554(169(416)(3(417(144(260(317)(916))(70(791)(109)))(272(128(333)(414))(755(634)(697))))(556(75(438(809)(857))(164(550)(576)))(298))))(330(753(137)(300(294(343)(896(959)(706)))(818(32(386)(80))(202(95)(785)))))(497(407(822(318(344)(197))(319(777)(113)))(836))(989(703(691)(164(165)(498)))(175)))))) +(396(724(264(500)(455))(328(15(925)(274(524(427)(509(164)(400)))(380(845(545)(369(845(278(184(37)(850))(769(552)(647)))(729))(96(191)(573(803(970)(526))(21(295)(844))))))(484(239(28(979(557(805)(153))(951))(646(358(50)(890))(374(522)(289))))(478))(755)))))(376(615(589)(799))(811(93(51(815(83(836(958)(376))(455(197(975)(653))(367(654)(945))))(968(399(347(94)(187))(567(12)(809)))(515)))(72))(281(839)(449)))(857(583(135(93(183)(589(625)(617)))(538(847(940(191)(619))(726(240)(167)))(67(667(650)(944))(839(750)(238)))))(9))(463(912)(104)))))))(427(490(126)(405))(27(579(454(260)(550(395(878)(278(811)(311(97(14)(257(342)(399)))(478(213(763)(510))(927)))))(749)))(820))(744(864)(159(932(266(123(743(753)(491(481(725)(472))(830(564)(241))))(133(133(116)(453))(312(627(299)(190))(114(813)(347)))))(662(773(853)(440(688(297)(268))(511(137)(795))))(779(373(816(705)(702))(924))(713(738(436)(303))(28)))))(57(782(367(726(528(347)(357))(281(746)(892)))(87))(548(673(18(544)(41))(766(489)(496)))(935)))(792(417(34)(77(228(640)(148))(634(811)(990))))(184))))(83(682)(46(520)(914)))))))) +(812(323(627(316(479(971(438(688)(333))(422))(646))(914))(102(662(772(43)(681(862(35)(729))(830(24)(926))))(509(38)(844(833(627)(80))(655(803)(389)))))(327)))(178(678(626)(182(176)(294(484(346)(161(814)(308)))(824))))(814(310)(226(800(76)(785))(62(649)(946))))))(210(144(274(179(932)(437(754(242(78)(154))(250))(838)))(306))(309(289(895(916(850(962)(971))(452))(512(132(64)(845))(780)))(374(85(761(428)(223))(804(425)(339)))(523(912(690)(733))(441(112)(833)))))(463(408(318(807(334)(162))(911(256)(841)))(529(607)(334(116)(13))))(239))))(203(161(534)(602))(353)))) +(529(760(402(704(675(10(513(363(340(934(195(916)(190))(369(989)(160)))(65(725(236)(49))(404(454)(220))))(933))(205(727(481(580)(191(285)(120)))(47(607(151)(619))(661(821)(740))))(551(463(635)(380(267)(667)))(676(395(496)(510))(91(495)(824))))))(803(445)(675(773(217)(173(331(823)(234))(20(311)(289))))(951))))(682(901)(504(415(677)(679(985)(38)))(380(331(294)(371))(23)))))(752(341(66)(6(413(854(585(691(853)(295))(343(494)(831)))(997(359(156)(114))(137)))(923(116)(733)))(389(723(815)(956(498(933)(659))(406(167)(199))))(771(180(96(673)(701))(667))(857)))))(615(609(993(822(594)(450(606(208)(422))(564(866)(486))))(447(193(196(582)(765))(840(842)(614)))(615)))(899(595)(67)))(661(285(98(718)(726(414)(509(630)(184))))(164(619)(710)))(390)))))(342(468(60(437)(15(233(843(863(980)(324))(982(649(947)(683))(593(601)(330))))(269))(838(759(968(750(841)(653))(435(727)(913)))(241(94)(670)))(555))))(936(718(573(925(734)(537))(542(228(424(387)(315))(426(795)(781)))(67)))(680))(933(107(472(355(218(193)(270))(623(394)(818)))(181))(701(870(542(111)(554))(419))(310(933(726)(117))(255))))(123(813(749(352(404)(990))(766(113)(7)))(5))(825)))))(545)))(616(338(541(34(916(172(382)(921(114)(773)))(704(448)(980(927)(108(737(367)(28))(608)))))(865(591)(499(949(592(431)(765))(20(309(726)(502))(712)))(148(173(257(159)(117))(135))(900)))))(874(628(960)(676(531(334(438(469)(846))(230(725)(585)))(735(53)(628)))(684(850(63)(950(673)(274)))(544(12)(988)))))(33)))(122))(343)))(52(226(251)(375(507(538)(940))(608(315(400)(300(460)(782(802(148(779(358)(959))(829(333)(525)))(429(921(686)(402))(146)))(678))))(659))))(99(669(111(66(742)(777(944(343(411(683(839)(322))(118))(684))(838(311(352(50)(362))(634(573)(323)))(775(4(654)(233))(162(449)(909)))))(528(130(110(469)(116(923)(663)))(524(958(887)(814))(654(69)(59))))(903(310(138(290)(752))(100(508)(513)))(950(678(19)(512))(898(908)(968)))))))(56(730(756(786(46)(827))(775(28)(772(836)(607(883)(120)))))(438(821)(612(258(247(539)(771))(318(581)(427)))(159(483(159)(66))(304(791)(807))))))(397(211(496)(444(342(237(816)(723))(995))(508(822)(549(275)(604)))))(252(515(718)(525))(898(630)(992(378)(701(451)(738))))))))(197(92(243(214(743)(72(32)(309(205(94)(778))(774(508)(252)))))(50(197(789)(261(918(894)(916))(761(138)(820))))(107)))(477))(463(499(213(452(805(158)(885(120)(892)))(990(860(336)(760))(352(818)(734))))(546(729)(813(621(707)(441))(661(36)(827)))))(658))(705(787)(623(51(386(360(800)(253))(502))(702(912(386)(632))(170(648)(869))))(195(426)(804(434)(446))))))))(684)))) +(212(454(677(225(655(101(997(203)(529))(976(769)(58)))(800(500(517)(747))(665)))(874))(581(189)(215(89(838(367)(820))(614(107)(320)))(475(399(110)(997))(223)))))(245(855)(869(885(813)(388(243(338)(188))(221(898)(482))))(7))))(153(228(330(448(181(26(287)(246))(855(193)(404)))(472))(146))(41(696(432)(798))(514(235(779)(884(71)(503)))(941(509(575)(216))(521(827)(234))))))(649(937)(778)))) +(629(269(370(416)(444))(951(570)(665(782(695(691(931)(813))(315))(60(616)(12(181(945(261)(669))(525(487)(907)))(983(75)(503(592)(360))))))(501))))(310(186(101(736(472(857(451)(842(473(429)(420))(255(348)(309))))(783(356(881(598)(22))(884(504)(125)))(64(94)(525))))(905))(314(286)(696)))(3(454(85(2(292(126(568)(172))(833))(515(881(360)(773))(694(276)(91))))(387(896(266(610)(815))(726))(507)))(352(865)(244)))(106(146(829)(419(130)(393(249)(278(736)(294)))))(716))))(206(53(604(693(635(646(690(759)(493))(27))(980))(376(770(790)(277))(936(829(971)(234))(946(82)(374)))))(351))(678(204)(423(215)(963(11(13(602)(734))(305(196)(671)))(442(317(340)(705))(173))))))(393(32(174(436)(334))(536(147)(324)))(991))))) +(366(957(843(140(214(755)(408(487)(162(452(225(281(863)(484(68)(68)))(309))(428(59(752(29)(49))(786(515)(321)))(78)))(882(125(279)(983(141)(503(129)(777))))(688)))))(939))(148(869(249(302(563)(28(597(505)(616(597)(685)))(215)))(382(553(790(416(950)(433(507)(276)))(28(798(905)(20))(789(934)(213))))(889(888(623(13)(47))(838(861)(296)))(604(544(382)(580))(18(371)(605)))))(572(380(602(37(955)(885))(720))(452(232(275)(1))(999(383)(338))))(100(724(617(900)(719))(658(560)(790)))(632(750)(98))))))(886(691(96)(504(112(453(611(124)(792))(620(850)(228)))(313(128(230)(326))(195)))(50(853)(41(459(856)(317))(4)))))(380)))(955(790(670(706(37(725(635)(336(690)(909)))(215))(983(977(258)(865(438)(688)))(414(206(921)(850))(77(384)(913)))))(973(700(202(395(908)(308))(266(836)(326)))(909(11)(873(986)(262))))(797(421(968(794)(755))(235(13)(53)))(336(195(938)(140))(637(257)(609))))))(979))(379(144)(445(825)(128(710(990(606(896)(992))(238(845)(804)))(942(547(901)(911))(913(865)(26))))(25(728)(603))))))))(33(880)(5(597(277)(347))(240(374(119(609(69(496)(354(5(689)(927))(553(2)(902))))(743(711)(929(792)(897(560)(348)))))(570(48(434(107(519)(310))(182))(704(621(759)(64))(841)))(204(448)(525))))(618(645)(877)))(468(852)(527))))))(629(75(638(587(475(847)(337(861)(157(769)(31(28)(900)))))(161(780(299(700(189(566)(779(517)(536)))(517))(893(784(2(25)(277))(548))(519(388)(318(441)(185)))))(813(197)(503(577(597(806)(341))(240))(354))))(540(857)(444))))(863))(837(719(189)(796(778(401(79(663(492(947)(970))(575(586)(577)))(52(592(352)(46))(160)))(416(274(898(448)(846))(983(73)(381)))(90(874)(924(254)(244)))))(402(925)(295(149)(537(195(632)(820))(25(151)(734))))))(614(299(449(431)(534(787(548)(262))(821(622)(657))))(711))(478(564(988)(44(752(65)(969))(245(769)(390))))(705(613(596)(941))(326))))))(128(647(353(303(587)(212(556(674)(276))(657(67(405)(496))(886))))(917(544)(723(531(794(97)(337))(587))(879(532(858)(257))(381(567)(612))))))(6(386(599(323(772)(287(449)(323)))(642))(73(463(222(813)(637))(14(880)(303)))(19(458(231)(527))(612(638)(799)))))(389)))(182(291(132(352(700(170)(496))(158(931)(489(788)(104))))(312(7)(843)))(279))(654(397(729(6)(188(459(187)(646))(851(963)(328))))(488(614(117)(668))(243(259(999)(468))(779(198)(752)))))(670(553(445(392(191)(557))(207(119)(96)))(181))(190(767(898(1)(588))(504))(462(661(546)(40))(593(49)(876))))))))))(92(629(253(115)(327(441(737(778(393(865(387)(977))(663(468)(881)))(123(170(273)(117))(55(89)(2))))(469(912(869(676)(960))(290(21)(139)))(817)))(257(5)(484(978)(707(896(74)(967))(902)))))(136(603(381(691(230(108)(293))(497(2)(302)))(186(198(184)(901))(788)))(344(429(798)(80(626)(45)))(254)))(206(33)(18(547(293)(733(555)(834)))(70(509)(352)))))))(80))(283(851)(366(412(26(118(67(946(883)(510(303)(716)))(474))(746))(156(610(67(749(524)(376))(801(246)(982)))(919(626)(630(829)(396))))(858(612(157(285)(201))(868))(579))))(955(467)(974(296(545)(587))(451(594(99(483)(313))(359(323)(228)))(375(150(69)(958))(388(660)(995)))))))(372(785)(496(684(207(791)(196))(93(156(803)(649(706)(323)))(573(902(558)(742))(824(829)(775)))))(235(659(57(222(519)(237))(952(682)(329)))(487(929)(805)))(95(115(18)(518))(985(403)(793))))))))))) +(365(425(1(856)(393))(741(830)(219(688)(615(33(619)(964(346(686(668)(209))(223))(256(928(94(799(619)(18))(48))(114))(110(393(722)(557))(628(609(476)(582))(158))))))(308(755(419)(160(389(653(673(126)(340))(264))(561(185)(861(231)(726))))(674(771(648(642)(483))(569))(628(502(822)(625))(916(168)(596))))))(733))))))(364(49(346(165(938(721)(951(618)(741(323(244(285(532)(936))(647(422)(855)))(665(198(28)(352))(952(115)(922))))(721))))(608(779)(856(193(681)(794))(629(635)(506(342)(953(179(399)(189))(617)))))))(94))(739))(884(604)(581(49(189)(653(576(734(415)(682))(291(52(494(798(401)(928))(613(181)(151)))(956(807(119)(992))(151(458)(580))))(293(877(986(725)(342))(47))(701(300(809)(477))(63)))))(250(300(671(73(431(866)(323))(563(480)(79)))(384(291(881)(609))(24(736)(946))))(60(52(560)(222))(921(834(570)(807))(579(944)(394)))))(934))))(775(972(919(23(95(852(874)(305(457)(808)))(589))(324(122)(991(990)(324))))(618(814)(551(442(364(868)(963))(531(36)(475)))(551(176(276)(496))(802(749)(115))))))(939(531)(686(779(466(733(708)(15))(167(26)(582)))(742))(227(698(795)(224(73)(198)))(484(364(36)(286))(510(466)(548)))))))(251)))))) +(963(87(648(755(191)(334(790(853)(584(434)(84(13(549(699)(53))(429))(871))))(71)))(51(823)(977(2(252(316(345(142)(594(198)(697)))(934(992(916)(817))(600(337)(603))))(867))(344))(262(914(241(32(52(95)(174))(381(384)(158)))(110))(733(200(273)(211))(844(536(625)(167))(293(61)(283)))))(808(189(617(742(924)(812))(508(217)(394)))(100))(908(330)(754(499)(585(354)(129)))))))))(461(950)(520)))(261(831(276(290(641)(101(343(566(278)(367(618(47)(595))(358(328)(537))))(149(684)(612(805)(769(816)(578)))))(280(258(825(926(879)(606))(193))(564))(71(630(293(732)(946))(712(473)(625)))(374(67(218)(854))(895(862)(220)))))))(957))(861))(661(64(880(162(868)(654(251(465)(650(708(567)(669))(480(629)(825))))(734)))(743(413)(776(282(374(680(629)(384))(651(574)(174)))(357(835)(514(434)(570))))(904(994(219(989)(679))(977(539)(365)))(804(255(405)(986))(76(170)(185)))))))(457(230(341)(892(678(70(654(201)(978))(422))(502(312(773)(106))(857(770)(750))))(824(52(654(397)(186))(862(907)(82)))(960(239)(298(551)(854))))))(116)))(352(929(110(132(637)(12))(114))(565(540(413)(314))(39(287(826(757)(642))(398(916(351)(451))(925(909)(727))))(521(751(437(18)(293))(611))(23(665(487)(873))(609))))))(603))))) +(991(212(432(0(746)(924))(617(505)(327(629)(597(321)(836)))))(389(984(521)(38))(514)))(310(341(782)(246(222(564(951(759(323(682)(259))(532(407(680)(494))(754)))(83(634(232(70)(72))(515(588)(644)))(968(267(985)(86))(239(335)(637)))))(437))(751(53(581)(353(191(675(402)(120))(189))(787(559(285)(474))(765))))(126(168)(235(777)(264(685)(968))))))(39)))(804(817(424(512(887)(134(603(807(360(348)(254))(468(10)(352)))(829))(445(471(447(45)(637))(669))(720(938(560)(221))(510(609)(510))))))(204))(706(528(498)(769(667(915)(36(332(635)(584))(626(599)(888))))(690(287)(173(412(571)(630))(273(434)(874))))))(775)))(354(269(109(379(258(542(754(774)(853))(537))(502))(713(582)(605(662(755)(36))(575(172)(227)))))(292))(147))(130))))) +(507(30(140(749(204)(234(249(554(539(836)(9(663)(437)))(722))(768(160(624(127)(783))(865(41)(793)))(310(742)(694))))(153(715(887(272)(525(627)(399)))(612(627(65)(560))(680)))(237))))(378(222(49(196(434)(118(675(755)(719))(498)))(401(105(363(19)(548))(569(352)(715)))(657)))(378(957(613(395)(518(133)(545)))(967(570)(607(961)(245))))(530(625)(75(76)(901)))))(174)))(762(847(530(373)(55(480(32(554)(387))(161))(563)))(501(3)(109(769(251)(323))(833))))(152(928(233(535(161(838(913)(61))(816))(673(375)(131(451)(543))))(121))(10))(827))))(989(850(965(986)(894))(674))(157(71(400(659(794(17(703(544)(549))(732(707)(499)))(529(939(253)(588))(986(920)(589))))(146(317)(939)))(364(881)(801)))(919(589)(344(827(329(206(812)(910))(238(627)(182)))(488))(113(867(813(457)(886))(74))(352(447)(246(590)(707)))))))(148)))) +(494(696(54(206(236(544(467)(226))(932(327(332(425)(940))(751))(463(571)(768(860(652)(778))(423(87)(479))))))(916(850)(271)))(404(929(457(922)(187(394(176)(46(899)(232)))(208(753(644)(718))(746))))(841))(789(659(902(481(964)(767(273)(745)))(988(808)(188(529)(545))))(656))(545(953)(512(638(273)(200(915)(751)))(960(255(752)(880))(794(593)(953))))))))(250(534(470(889(676)(268(654(520(730)(156))(506))(721(991(574)(253))(495(93)(766)))))(132(282(138(973(731)(1))(795(312)(496)))(292(371(909)(322))(423)))(54(789)(388))))(730(343(332(395)(694(586(468)(344))(282(335)(64))))(427(515(500)(221(958)(465)))(597)))(427)))(554(581(59)(569(50)(88)))(359))))(839(328(939(877(699(624(810(551(635)(239))(914(691)(577)))(933))(710(225(187)(353))(23(352(375)(186))(731(1)(277)))))(735(917(439(619(979)(311))(820(210)(117)))(484))(425)))(239(593(210(986(716)(381(860)(732)))(741(3(661)(971))(968)))(526(264(532(364)(340))(740))(324)))(202(272(125(388(418)(162))(333))(130(12(428)(185))(284)))(0(219(632)(812))(632)))))(808))(662(13)(410(443)(375(635(816(757(769(636)(739))(629(988)(248)))(476))(719(224)(728(329)(386(706)(693)))))(181(366)(595))))))) +(420(450(527(243(482)(130(199)(34(648(718(993)(215(748)(563)))(290))(303(698(917(854)(324))(966(37)(947)))(471)))))(552))(487(216(910(604(465)(982(813(831)(788(115)(31)))(572(470(43)(315))(330(991)(688)))))(635(974)(389)))(910))(439(640(836(95(130(410(757)(649))(229(659)(705)))(675(477(505)(424))(752(130)(509))))(26))(691))(718(7(58(953)(840(530(594)(301))(243(955)(791))))(77))(55)))))(682(380(558(469(455(449(205)(757))(164))(439(358(104(781(962)(717))(938(624)(758)))(102))(778(841(607)(972(880)(945)))(156(948)(841(541)(423))))))(631))(241(346)(958(741(917)(949(97)(813(627(72)(872))(297(287)(312)))))(17(87(780)(636(515)(139(820)(616))))(890(921(246)(343))(111(599)(850)))))))(983(322(398(608)(801(479(700(448)(488(958)(783)))(30(334)(895)))(104(2)(620(333(722)(524))(470(73)(312))))))(402(860(82)(62(805)(158(286)(23(217)(376)))))(1(566)(976(254(112(77)(834))(75(626)(307)))(763(226(484)(362))(328(566)(758)))))))(406)))) +(443(975(318(463(260)(832))(968(854)(292(691(177(32)(79))(959(580)(51(293)(155))))(890))))(723(209(659(95(266)(684(903)(635(684)(170))))(403))(697(626(731(944(550)(454))(466(83)(755)))(272(455(879)(596))(752)))(377(492(973(823)(302))(173))(699(748)(776(48)(215))))))(443(812)(485(34)(120(456(633(357)(818))(777(500)(912)))(811))))))(144(595(370(489(847(151(607(959)(938))(364))(783))(680(228(339(983)(734))(554))(815(445)(798(669)(544)))))(146(830)(601)))(746))(553(279(72(742)(79(225(58)(146(672)(450)))(212(127(511)(916))(34(561)(148)))))(172(306(258)(8(532(374)(524))(951(381)(269))))(284(408(267)(821(129)(692)))(177(848(10)(944))(885(855)(510))))))(783(807)(271))))) +(455(339(734(839)(929(695(655(650(560)(829))(600(92)(660)))(997(442(697)(627))(664(471)(557))))(474(823(208(344)(744))(471(209)(566)))(947(999)(581(614)(767))))))(839(536(747)(881))(460(524)(252(829)(278)))))(228(853(925)(288(203(216(960(443)(160))(55))(993(385(170)(251))(419(390)(434))))(964)))(802(512)(956)))) +(73(767(422(408(82(896)(362(23)(82(839(488(228(339)(739))(891(977)(483)))(487(531(817)(36))(584(20)(773))))(437(89(372)(765(166)(72)))(376(824(195)(867))(397(225)(785)))))))(651(626(375(30(27(563)(960))(194))(92(937)(42(491(921)(302))(775(998)(930)))))(565(419)(441(992)(751(292)(517(436)(769))))))(807)))(1))(900(806)(189(650(16)(863(22)(339(845(46)(67(52)(389(641)(411))))(153(362(461(524)(310))(207(465)(275)))(311(17)(974(857)(716)))))))(683(618(381)(749(598(979(604(556)(698))(352(394)(913)))(36))(195)))(140)))))(478(532(738(352)(522(209)(627(837(624)(81(869(508(149)(313))(449(953)(683)))(40(833)(575(89)(307)))))(798(406(784(278)(671(275)(458)))(989))(644)))))(58(252(86(930(739(357)(846(626)(334)))(672(550)(754(796(868)(41))(316(331)(324)))))(164(148(310(169)(913))(804(824(859)(920))(243(67)(735))))(876(381(344(354)(15))(571(877)(29)))(419(282)(135(490)(581))))))(530(251(410(175(892(989)(834))(593(558)(235)))(811))(52(226)(511(646(443)(706))(704(217)(968)))))(984(443)(923(792(129(60)(420))(194(705)(291)))(409)))))(803(209(21(604(494(53(232)(704))(924(338)(746)))(891(87(133)(384))(669(195)(358))))(550(853(291(482)(815))(755(740)(7)))(490(104(201)(466))(303))))(602))(779(557)(86(677(524(636(579)(84))(96(173)(520)))(109))(168))))))(591(556(598(27)(457))(851))(542)))) +(65(232(525(329(183(74)(953(331(995(8)(128))(257(699(151)(934))(705)))(878(622(758)(327(246)(101)))(680))))(9(12(776)(174))(77(541(432(604(363)(98))(615))(586(266)(390(30)(372))))(785))))(199(20(593(884(271)(589))(609(519)(516(300(328)(211))(307(263)(359)))))(203(947(838)(42))(828(517(407)(485(886)(849)))(666(464(353)(684))(644(995)(720))))))(845)))(386(85(512(245(724(405(348(552)(382))(913))(669))(571))(834(781(185)(836))(843(909(36(65)(610))(142(505)(838)))(214(697(573)(881))(720)))))(507(553(159)(258))(847(122)(840(115(868(206)(662))(17(771)(982)))(572(290(24)(746))(666(783)(986)))))))(405)))(45(87(707(530(711(613(585)(947(823(635)(742))(315(82)(988))))(291(495)(433(749(570)(474))(592(823)(432)))))(712(629)(419(338(114(965)(419))(107(19)(335)))(674(720(910)(769))(25(210)(569))))))(711(78)(498(715)(674))))(721(187)(942(965(621)(433(57)(772)))(345))))(566(848(192(160(483)(390))(870(596(42(120)(366(485)(275)))(235(963(446)(869))(62(37)(354))))(603(457(678)(745(947)(28)))(614(495)(681(766)(588))))))(138))(617)))) +(475(409(68(109(84)(634(702(945(49)(477))(147))(287)))(356))(994(313(788)(151))(32(594(420(384(938)(491))(831(52)(196)))(338(402)(281)))(290(286(294(364)(927))(603(797)(200)))(348)))))(675(497(397(726(127)(444(891(993)(623))(327)))(586(8(118(300)(946))(716))(952)))(567))(326(805(989(391)(796(319)(436)))(747(802(189(416)(594))(772(951)(952)))(282(14)(97(830)(415)))))(977)))) +(131(145(274(990)(612))(201(139(655)(119(730(229)(803(80(312(811(374(959)(863))(180(867)(703)))(46(385)(79(181)(218))))(188(223)(956(487)(435))))(327)))(661)))(316(883(534)(315(803(248(251(84(788)(945(978)(483)))(309(321(656)(3))(49(464)(40))))(438(810(9(688)(994))(340(718)(852)))(28(175(949)(455))(559(609)(367)))))(225(828)(294)))(798(424(69(453(84(526)(852))(577))(811))(620))(789(560)(511(81)(324))))))(500(832(378(537(3)(156(942(768(149)(699))(286(917)(914)))(763)))(823(716(381(322(812)(237))(586(618)(644)))(222(479(446)(293))(306)))(850(379(563(383)(519))(371(752)(934)))(76))))(13(480(91(107(431(576)(52))(515(99)(812)))(237(68)(671(891)(809))))(69(255)(504)))(501(764(790)(687(246)(2(66)(306))))(682(560(31)(174(860)(794)))(922(533(593)(294))(870))))))(98(239)(857(491(684)(788(254(723(704)(180))(212))(167)))(54(404)(404(599(127(980)(956))(56))(801(569(267)(733))(841(871)(272)))))))))))(265(823(681)(373(261(54(471)(635(463(506(941)(860(184)(431)))(851))(435(741(26(790(871)(733))(944(526)(498)))(938))(1(211(92(981)(690))(534(499)(975)))(279(987)(129(195)(434)))))))(139))(587)))(608(72)(45(716(229(30(347)(773(265)(539(602)(912))))(455(907(859)(775(56(270(805)(884))(523(45)(342)))(219(215)(194))))(186(821(828)(978(555(971)(116))(106(575)(597))))(295))))(107(792)(237(451(219(517(252(114)(963))(374))(535(85(726)(941))(366)))(758(61(25(923)(539))(28))(76)))(843(382(584(813(123)(105))(712(953)(328)))(798(108(186)(828))(917)))(255)))))(418))))) +(642(524(376(111(612)(962(336(157(56(738)(252(164(990)(656(271)(12)))(262(406(250)(455))(478(42)(537)))))(822(408(51(318)(392(48)(402)))(995))(270(524(975(727)(246))(437))(86(369(747)(755))(909(697)(685))))))(982(492(787(914(671(617)(327))(512(365)(814)))(412))(534))(467)))(32(187)(103(343(605(727(330)(559(266)(489)))(889(901(248)(945))(212(393)(474))))(256))(361)))))(470(629)(738(786(518)(724(233(779(711(854(444)(615))(768))(765(607)(7)))(253))(220(979(350(21)(501(949)(739)))(662))(949(620(700(767)(294))(972(28)(892)))(784)))))(376(729(695)(476(683)(540(410)(646))))(142(398(241)(877(77)(539)))(133(930)(821(222(84)(554(120)(433)))(573))))))))(352(538(789(466(254(834)(778(295(698(428(103)(234))(736(107)(546)))(270))(47(262)(599(6(791)(409))(879(191)(795))))))(770))(830(172(671(405)(416(897(174(122)(680))(23(971)(498)))(702(422(17)(297))(44(368)(130)))))(918(540(154(576(86)(505))(397(116)(311)))(727(393(17)(25))(769(187)(675))))(311(222(381)(850(308)(584)))(396(557(609)(786))(471)))))(325)))(908(156)(506(640(283(270)(321(462(958(85)(914))(323))(978(502(59)(218))(971))))(614(626)(850(466(794(228)(720))(636(81)(636)))(657(628)(115)))))(173))))(851(127(444(242)(631(854)(803)))(458(956(354(217(377(363(688)(183))(745(722)(828)))(408))(831))(584(410(567(737(557)(575))(110(93)(779)))(143(620(853)(381))(505(313)(870))))(266)))(821)))(751(183(206(990(352(550)(926(883)(15(750)(654))))(336(869)(572)))(121(146(714(385(380)(320))(253))(578(671)(350(481)(50))))(849(555)(973))))(752))(478(587(951(117(521(175(525)(117))(929(64)(905)))(206(49)(611(312)(487))))(560(248(222)(543(880)(379)))(120(758(168)(492))(903(145)(161)))))(539))(789))))))(14(99(473)(822(49(960(325(628(511(515(738)(88))(49(765(549)(395))(932)))(227(565)(278(897(538)(991))(482(601)(112)))))(115(916(231(281(427)(360))(238(138)(172)))(797(83(422)(646))(680(365)(50))))(294)))(648))(64(7(52(684)(369(356(991(59)(748))(589))(924)))(24(401(293(470(417)(580))(435(640)(516)))(243(412)(222)))(342(849(557(962)(552))(89(707)(667)))(528(942(953)(49))(568)))))(143)))(222(564(438)(0))(352(947(593(508(73(712)(947))(422(445)(361(297)(141))))(180))(770(83(263(770(175)(137))(302))(849(102(115)(415))(688(553)(476))))(666(931(218)(60(411)(711)))(784))))(776)))))(694(519(226(181(19)(394(803(576(6)(284(915(177)(127))(326(132)(146))))(166(972)(996)))(437(920(652)(530))(397(38)(473)))))(324(683(726)(524(605)(1(866(967(955)(6))(21(278)(638)))(551(348(604)(628))(926(857)(758))))))(113)))(113(36(367(371)(810(859(312(908(95)(410))(892(248)(630)))(660(476(286)(727))(463)))(860(979(93)(358(10)(186)))(746(608(152)(391))(382(742)(606))))))(618))(85)))(387(861(385(498(101(91(949)(820))(728))(568(502(99)(723(322(530)(223))(698(610)(944))))(286(11(955(795)(607))(68(227)(138)))(520(786(945)(652))(944(174)(290))))))(984(954)(712)))(753))(826(632)(990)))))) +(856(996(876(525)(973(564(607)(316(599)(529)))(622)))(786(486(674(358(719(429)(742))(261))(161(73(586)(841))(772(653)(408))))(586(786(695)(126(280)(629)))(388(14(665)(143))(85(945)(797)))))(592)))(910(208(767(404(290)(386(813(29)(174))(849(265)(424))))(864))(432(381(689(684(299)(846))(205(911)(111)))(702(524(484)(236))(142(156)(705))))(985(63(450(144)(31))(841))(205(706)(597(685)(768))))))(862(332(227(563)(531(446)(844(191)(406))))(509))(992(560(921)(644(418)(519(178)(64))))(84))))) +(176(101(948(912)(486))(928(57(356)(199(755)(211(569(605(596(954)(618(319)(393)))(146))(890(855(688(129)(106))(982))(46)))(828(549(717(775)(460(58)(452)))(370))(708(506(313(442)(200))(521(62)(352)))(149))))))(64(150(4)(96))(944(30(619(77(587(701)(11(478)(837)))(984(547(148)(696))(773(262)(270))))(668))(802(166)(789(148(721(917)(265))(20(330)(271)))(155(608)(29(109)(950))))))(848(530(11(620(288(440)(906))(18(692)(294)))(296(335(256)(353))(499)))(872))(949))))))(819(68(181(382(370(295(681)(117(662(946(994)(184))(961(875)(933)))(221(242(919)(615))(197(155)(622)))))(587(718(490(708(555)(878))(635(316)(218)))(884))(231(280(186(96)(483))(828))(688(155(87)(185))(289(928)(929))))))(422))(968(809(918(289(663)(326))(453(20(518)(744))(96(267(972)(243))(239))))(738))(672(337(59(844(404)(403(572)(174)))(102))(675(832(699)(755(660)(825)))(345)))(401(226)(17)))))(25(120(102(301(260(830)(305(979(689)(549))(586(897)(364))))(579(177)(476(946(956)(947))(626(520)(711)))))(216))(692(457(731)(264))(372(846(4)(868(78(433)(303))(0(310)(211))))(311(790(151(876)(99))(181))(356(536(445)(745))(781))))))(919(736)(659(591(118(150(448(608)(362))(405))(991(485(84)(53))(964)))(611(758)(183(961(302)(811))(932(660)(977)))))(774(841)(995(332(10)(291))(963(387)(791(604)(888)))))))))(336(632(785(158)(771(554)(230(12)(510(528(812(803)(30))(504(577)(129)))(950(84)(521(626)(149)))))))(454))(226(380(215(777(654(50(965(970)(799))(556(859)(637)))(896(539(125)(419))(518(323)(687))))(504(59(674(743)(547))(490))(526(904(158)(916))(980(100)(389)))))(101(291(70(939(804)(239))(107(16)(310)))(914(364(583)(966))(333(593)(867))))(956)))(213(260)(568(407(697(761)(215(87)(576)))(598(467(555)(464))(940)))(137(613(562(256)(380))(973(194)(463)))(38(97(235)(534))(370(103)(831)))))))(779(877(268(508(434(316(812)(716))(631(905)(478)))(203))(700))(167(236)(524(846(117(676)(501))(402(71)(558)))(159(310(967)(491))(635(870)(178))))))(494(583)(54))))))) +(852(666(196(965(46(969)(50(560)(653(736(977(174)(799))(579(610)(187)))(535(224(319)(905))(659)))))(16))(823))(166(432(547(118(22(308)(222(604(187)(673))(810(780)(109))))(598(435(31)(945))(291(95(217)(110))(277(11)(311)))))(704(456(508(118(85)(886))(29))(614(497)(156(232)(940))))(768(756(268(535)(592))(302(651)(89)))(656(136(606)(255))(337)))))(5(615(988(615)(257))(289(279)(652)))(459(207(213(506(469)(919))(312(955)(974)))(210(94(775)(751))(114(374)(289))))(970))))(823(677(631)(111(23(70(252(833)(937))(96(627)(806)))(429))(849(810(700(99)(288))(809(712)(245)))(175))))(150(496(107)(967(247(953)(779(238)(795)))(707(186)(458(789)(128)))))(722(937)(694(205(529(73)(285))(608(130)(689)))(230(640(404)(451))(397(610)(485)))))))))(817(111(479)(493(640)(976)))(968(787(853(363)(810(352(620(800(398)(118))(63))(12))(35(515(828(570)(819))(866(586)(853)))(525(661(770)(93))(10(747)(545))))))(336(535(871(826)(918))(174(983)(152)))(551(175(758)(786(348(667)(264))(736(80)(377))))(471))))(338)))) +(159(588(648(580(809(334)(867))(720(992)(823(948(191(789)(447))(11(359)(278)))(932(524)(721(60)(137))))))(699(706(432)(424))(611(268(284)(505))(732))))(77(634)(587(495(920(97)(858(188(258)(356))(183(499)(877))))(374))(268(602)(266(32(176(989)(520))(615(969)(852)))(864(507)(112)))))))(141(659(312(679)(919(995)(909)))(188(274(613(941(33(898)(115))(664(417)(577)))(380(811(344)(209))(909(275)(408))))(103(817)(477)))(524)))(265(696(0(31)(444(296(920)(416(933)(798)))(235(869(622)(274))(401(169)(71)))))(611(515)(179)))(725(444)(536(990(419)(543(369)(498)))(141(984(858(914)(322))(340))(469(623)(285)))))))) +(336(864(658(181(900(275(751(471)(226(569)(643)))(648))(425(374(862(656(527(498(55)(653))(346(235)(476)))(438(714(588)(255))(411(829)(304))))(841(825)(327)))(210(639(586(677(84)(344))(593(334)(397)))(480))(555(30(7(941)(522))(320(862)(219)))(444(70(5)(734))(385)))))(7(553(547(466(45(793)(99))(982))(649))(244(382(782(140)(514))(664(584)(980)))(871(627)(457(816)(985)))))(705(612)(465)))))(859(44)(481(103(25)(283))(767(652)(772)))))(187(874(904)(407(225(368(745(743(32(334)(573))(337(243)(16)))(287))(380(80)(694)))(307(471(214(186(343)(653))(357(46)(263)))(845(250(20)(404))(814)))(492)))(318(602)(184(78(508(755(237)(697))(300))(12(269(860)(437))(35(952)(395))))(292(59)(173))))))(778(520)(61(146(876(761(700)(860))(525(179(275)(726(905)(322)))(438(198(574)(622))(228))))(858(365(670(485)(409(64)(234)))(213(582)(672)))(129)))(796(703(103)(49(599(219)(677(685)(280)))(210(881(922)(470))(38(421)(210)))))(266(95)(119)))))))(778(858(717)(534))(80(141(544(254(690(614(507(629)(10(300)(952)))(667(144(301)(209))(53)))(434(13(344(404)(324))(460(81)(926)))(711)))(875(51(112)(744))(875(164(686(561)(754))(866(448)(165)))(395(118(713)(700))(905(476)(590))))))(990(8(118(265(379)(543(7)(953)))(49(166(588)(695))(446)))(616(877(854(645)(206))(842(910)(94)))(9(440(734)(949))(873(555)(141)))))(532(934)(143))))(229(380)(642)))(568(820(462(665(264)(144))(840(671)(174)))(629))(731)))))(237(896(502(564(870)(392))(655(91)(821)))(448(51(63(690(471(562(296)(75(803(55)(176))(811)))(285))(837(105)(697(147)(32(984(270)(942))(180)))))(922))(922))(535(309)(421(420)(547(340(778(333(342(682)(773))(104))(684(410(822)(239))(851(768)(114))))(229(309(154(258)(459))(122))(88(661)(146(603)(508)))))(945(12(185)(792))(580(191)(396(399(728)(640))(496)))))))))(754(978(819)(263(522)(970(857(736(971)(961(126)(219(491(237)(736))(884(6)(52)))))(443(588)(973(328)(4(295)(922(5)(690))))))(466(464(223)(193))(665(940)(607(771(566(60)(804))(764(805)(19)))(31(826(212)(502))(735))))))))(335(216(662)(84(675)(410(987(823)(90))(768(625(375)(982(623(730)(312))(274)))(182)))))(375(892)(883)))))) +(577(685(6(618)(759(796)(450(498(2)(339(178)(280(991)(469))))(855(524)(759(916(197)(616))(787))))))(589(294)(184)))(930(157(636)(101(799)(349)))(703(983)(449(371(93)(739))(590(735(820(620)(972))(31))(523)))))) +(803(725(134(693(276(173(744)(147(680)(339)))(865(417(509(912)(113(923(505(82)(883))(176))(669)))(831))(922(388(330)(424(452(795(836)(21))(619(315)(562)))(104(455(168)(335))(569))))(697))))(722(896(266)(831(164(913(244(152(186)(342))(767(837)(285)))(764(655(924)(283))(707(306)(297))))(175(705(463)(177(871)(291)))(233(653)(60(706)(698)))))(601)))(339(615(626(368(682(485(608)(294))(638(458)(944)))(584(753)(754(690)(658))))(273(169)(548(205)(387))))(866))(999(620)(734(56)(269(139)(187)))))))(65))(418(8)(699(181)(343(846(769(306(78)(371(685(476)(573(435)(981)))(829)))(392))(110(763(638)(711(326(608(680)(30))(681))(205(257(337)(275))(260))))(702(133(103)(628))(610(59(971(323)(883))(368(741)(660)))(20(39)(637(424)(523)))))))(551(729(833(353(689)(263))(482))(544(498)(898(394(429(310)(93))(224(68)(996)))(773(410(321)(206))(382(854)(689))))))(961(477(987)(948(714(157(528)(742))(442(392)(673)))(378)))(319(964(947(923(811)(231))(78))(216(34(561)(536))(691)))(749(989)(793)))))))))(845(423(802(247(372(222(754)(822(238(538(820(148)(569))(83(14)(749)))(820(987(24)(795))(475)))(333(500(697(743)(402))(13))(977(894(744)(831))(728(286)(3))))))(356))(309(252(234)(69(689(813)(340))(701(153)(143(259)(422(48)(799))))))(102(103(496(30(453(291)(959))(377(533)(174)))(422(397(67)(719))(590(332)(260))))(957))(892(400(498(280(476)(834))(162))(125(467(630)(843))(221(604)(446))))(561)))))(922))(764(689(15(120(946)(743(330(596)(527))(779)))(306(947(412(717(787)(490))(906(497(849)(893))(3(433)(378))))(559(717(99(837)(414))(495))(319(623)(760))))(61(680(454(453(479)(206))(567(378)(718)))(669(193(223)(863))(188)))(332(727(577(518)(699))(866(56)(869)))(566)))))(800(860(985(205(148(141(644)(70))(35))(669(808)(191)))(440(648(384(870)(773))(217))(606)))(189(888(618(671(395)(223))(245(624)(662)))(458))(977(172)(500(340(837)(404))(848(189)(800))))))(619)))(625(424(2(876(229)(460))(243(186(741(201(218)(371))(218(473)(249)))(408(581(359)(788))(957)))(435)))(81(993(808)(983))(350)))(889(465(505(461)(670(462)(84(426(806)(377))(53))))(941(956)(551(823)(169(645(359)(643))(661)))))(544(644)(220(699(848(656)(672(163)(964)))(991))(794)))))))(67(500(240(344(375(288(923(979)(467))(191))(49))(328(451)(426)))(162(96(615)(78))(429)))(97))(512(387(310(138(735(1(749(227(983)(201))(828(691)(893)))(1(202(979)(25))(137(56)(497))))(332))(234(383(40(117)(686))(188(763(680)(955))(442)))(553(668(232(699)(219))(136(761)(530)))(81))))(618(959)(440)))(35(734(848)(641(796(503(133(290)(873))(172))(274(570(232)(809))(208(474)(588))))(871)))(486(146(694(82(655(89)(126))(222(268)(721)))(166(286(832)(166))(528(274)(860))))(609(951(420(665)(813))(841(783)(587)))(388)))(861))))(643(925(143(71)(704(542)(137(977(54)(602(103)(293)))(166(997)(327)))))(461(783)(466(545(772(584(890)(726))(462(654)(911)))(876))(251(330(776(291)(578))(545(295)(16)))(176)))))(640)))))) +(573(195(565(887(553)(947(759)(624(744)(995))))(460))(827(479(69)(436(220)(224)))(613(962)(235(134(395(96)(650(2(215)(389))(790(144)(392))))(390))(889(273)(811(124(627(832)(85))(193(540)(579)))(178(176(749)(716))(757(920)(935)))))))))(461(797(233(779(229(535(501(905(894)(663))(493(342)(123)))(266))(443(588(996(376)(964))(712))(11(735)(907(536)(937)))))(369(561(661(123(311)(172))(327))(313(107(545)(357))(701(283)(927))))(700(211)(281(378(496)(83))(719)))))(905(502(215(96)(45(651(418)(169))(846(950)(222))))(653))(499(512(177)(247))(286(309(437)(306(610)(659)))(681(21(603)(88))(336))))))(306(328(984(453)(693(975(540(857)(489))(117(735)(843)))(414(721(827)(250))(134))))(44(577)(168)))(454(999(662)(685))(745(905(977(286(648)(219))(433(105)(526)))(35(564)(112)))(368(809)(450(407)(849(82)(105))))))))(554(880(779(460(181(953(439(964)(897))(59))(929(302)(793(322)(757))))(29(947(324(921)(986))(241(237)(30)))(957(155(629)(455))(183(263)(773)))))(313(884(328)(487(151(246)(136))(316(567)(517))))(707(439)(37))))(522))(777(295(932)(649(223(699(651(542)(980))(46))(363(873(643)(427))(811(219)(314))))(970(188)(802))))(94))))) +(148(110(756(559(287)(578))(66(113(415)(320(364(636(995)(663))(101(538)(479)))(691(916(147)(404))(346))))(610(815(815(775(678)(598))(486(61)(340)))(154(578)(476)))(316(29(286(138)(871))(252(134)(609)))(116(415(708)(0))(511(213)(189)))))))(216(67)(466(999)(637(628)(83(367(636(225)(748))(779(908)(257)))(131))))))(64(826(945(229(308)(123(876(477(308)(319))(226(593)(597)))(290)))(935(931(149)(278(569(219)(357))(390(786)(615))))(151)))(957(25(950(877(90(855)(906))(692))(788(686(969)(182))(293(388)(32))))(662(63(582(900)(917))(256))(552(829(835)(955))(89))))(640(122(501(684)(152(372)(688)))(898))(9(52(528)(731))(946(26)(336(988)(581)))))))(839(307(660)(516(144(711)(605(39(489)(291))(763(359)(54))))(717(942(685)(892(52)(643)))(690(709(776)(996))(990(943)(962))))))(89)))) +(899(768(452(126)(211(769(533(767(835(530)(452(724)(998)))(473(609)(199)))(658(720(295(949(214)(990))(742))(658(361(14)(221))(739(147)(956))))(961(833(353(13)(682))(382))(505(306(5)(294))(293)))))(88(5)(60(164(151(611(920)(883))(302(478)(721)))(50(128(980)(267))(106(797)(814))))(952(524)(959(315)(595(469)(799)))))))(963)))(526(989(940(405(229(306)(310(349(38(828)(601))(887(621)(163)))(269(506(43)(386))(972))))(145(663)(545(406(682(645)(843))(48(286)(85)))(626(569(363)(994))(159(898)(324))))))(718(630(320(874)(703))(214(593(508(448)(695))(808))(945(606(725)(246))(446(949)(81)))))(246(18(695(384(595)(623))(505(772)(457)))(707(82(478)(886))(971)))(985(661)(741)))))(992))(834(313(446)(196))(325(993)(380)))))(853(668(806(258(427(645(35(568(76(935)(273))(690))(687(433(472)(548))(563(155)(118))))(597(70)(868(690)(749))))(562(124(508(43)(205))(14))(888(602(78(93)(914))(742(571)(985)))(476(663)(279(630)(219))))))(434(896(306(585(544)(862(498)(148)))(253))(719))(576(508(670(511)(939(466)(830)))(284))(138(740(646(624)(574))(29(144)(807)))(796(42(784)(264))(500(960)(447)))))))(49(713)(378(732(650)(702(783(320(538)(577))(249))(966(824(870)(272))(740(50)(339)))))(541(449)(521)))))(315))(556(330(759(648(924)(419))(968(332(146(872(999)(201))(351))(908))(253(479(863)(872(926(616)(418))(47(781)(609))))(276(570(772(137)(3))(493(137)(318)))(659(397(45)(440))(941(423)(311)))))))(3(302)(934(6(350(707(265)(372(954)(769)))(406(895)(832(274)(503))))(409(3(124)(399(223)(422)))(107(553(559)(930))(191))))(150(99(744)(784(713(291)(799))(68(905)(760))))(521(491(338(331)(519))(689(160)(261)))(471))))))(978)))) +(149(134(341(476(80(139(817)(642))(458(996(160)(784))(523)))(651(759)(412(819)(770(21)(488)))))(854(707(446(472)(722(765)(275)))(418(80(50)(193))(746(726)(241))))(430(369(450(763)(443))(737(914)(420)))(388))))(238(790)(295(554)(356))))(414(130(492(239(779(975)(105(992)(808)))(292))(89(773(468(99)(723))(688))(334)))(910(938)(650(947(266)(745(92)(143)))(344))))(82(446)(750(545(726)(275))(438(990(374)(571(418)(27)))(380)))))) +(227(232(166(722(506(717(947(527)(500))(563(67)(382)))(63(892)(954)))(665(44(330)(942(691)(618)))(465(593)(104(115)(202)))))(805(14(666)(659(256(927)(575))(536(33)(118))))(405(384(712(514)(50))(678(636)(563)))(133(938(191)(935))(246(572)(501))))))(625(942)(633(201(359(876)(296(672)(961)))(935))(772(478)(339(518)(257(119)(531)))))))(39(482(830)(738))(552(574)(230(52(396(596)(852(144)(702)))(959(35)(448(84)(280))))(478(82(764(856)(325))(235(639)(241)))(935(102)(955(903)(969)))))))) +(80(120(323(691)(921))(672(677(37(216(266(214(530)(786))(522))(440(892(374)(552))(874(459)(699))))(526(113(726)(612(381)(679)))(58(26(401)(490))(956(877)(154)))))(950(197(71)(253(687(573)(853))(873)))(94(936(179(383)(118))(916))(715(161(43)(708))(426(940)(855))))))(671(406(145(970(705(808)(61))(773))(27))(363(857(18(621)(646))(956(402)(553)))(244(997(851)(779))(877))))(229(540(684(512(98)(824))(270(0)(207)))(125))(849(489(255(375)(852))(749(328)(789)))(695))))))(943(462(816)(679(232)(737)))(83(813(553(973)(793(912)(111(744(68)(17))(751(319)(155)))))(421))(205(877(587(145(606(658)(119))(106(939)(254)))(342))(31(912(916(207)(170))(721(501)(219)))(876)))(242))))) +(361(590(696(221)(901(281(6)(151(879(581(678(61(910)(335(883)(850)))(594(951(207)(791))(305(765)(268))))(415))(620(147(147(77(408)(290))(964))(312))(306(160(401)(303(295)(310)))(623(240(822)(16))(954)))))(707(932(749(524)(421(347(502)(426))(391(359)(283))))(251(460)(422)))(152))))(901(26(82(374(22(937(669)(934(988)(456)))(849(320(362)(301))(994(929)(920))))(43(442(219)(621(470)(784)))(382)))(940(771(428)(419(888(604)(459))(545)))(262)))(103(98)(568)))(934(502(826(666)(149(746(544(937)(546))(970))(719)))(164(795(304(963)(331))(675(11(788)(417))(498(575)(876))))(785(290(137(190)(577))(282(759)(196)))(930(697(981)(532))(689(712)(899))))))(304(999(356(178)(95(356(607)(462))(949)))(970(474(38(75)(782))(665(296)(579)))(897(851(296)(235))(244(197)(831)))))(612))))))(522(581)(695(640(493(899)(657))(638(24)(186(128(325(356)(242))(271(415)(765(535(426)(625))(250))))(584(211)(876(82(51)(372(573)(200)))(54(423(34)(578))(669(121)(241))))))))(603(748(52(54)(73(322(931(897(481)(530))(872(314)(551)))(286(825(563)(898))(385(104)(872))))(949(256(34(829)(529))(310))(623))))(309(503(418(136)(331(218(926)(990))(879)))(649))(277(574(277)(762))(225(154(749(899)(415))(187(732)(587)))(713)))))(227)))))(308(903(529(654)(964(711(858)(739(417)(641(120(262(70(430)(586))(405(106)(981)))(185(198)(164(866)(279))))(196(594(708(898)(575))(955(359)(122)))(285(277(356)(940))(638(660)(861)))))))(457(717)(681(437)(199)))))(138))(858(54(193(612(808(544(865(733)(597))(598(215)(666)))(835(934)(450(103(601(482)(443))(881))(186(846)(518)))))(307(466(985(845(772(290)(104))(794))(453(986(870)(695))(367(769)(791))))(236(642(306)(411))(772(696)(198))))(783(156(744(841)(319(929)(303)))(868(711)(693)))(826(518)(49(422(71)(582))(281))))))(972))(146(808(483)(29))(51)))(18)))) +(788(640(948(971)(766))(483(209)(827)))(163(441(655)(638))(812(548(820)(913(798(680)(360(74(823(514)(470))(351(976)(887)))(576)))(537(935)(333(820(900)(256(766)(702)))(650)))))(722(234)(530(865(919(862(46(507)(813))(448))(661(946(721)(811))(927(61)(747))))(253(147(27(892)(843))(63(474)(603)))(198(279(811)(734))(85))))(378(717)(685(726(739(803)(243))(850))(995(140(902)(524))(757))))))))) +(857(510(140(224(959(282)(868(631(4(101)(627))(736(877)(858)))(358(67(502)(189))(352(957)(127)))))(261(463(110(448(380)(708))(877(11)(659)))(138(221(12)(707))(222(313)(983))))(351(42)(3))))(791(533(71)(178(246(996(22)(848))(6(160)(354)))(347(867)(633(333)(67)))))(410(963(372(274(162)(734))(401(130)(638)))(846(28)(872)))(589(341(910(158)(263))(365(715)(77)))(500(859)(746))))))(553(485(71)(463))(99(281)(522(921(683(516(461)(233))(978(908)(702)))(550))(47(364(982(725)(183))(905(14)(340)))(717))))))(520(285(761)(249(827)(526)))(723(918(371(236(158(831(846)(376))(457))(301))(150(542)(428(68(639)(471))(58(948)(370)))))(748))(811(807(284)(433(905)(870)))(517(861)(334(621)(241))))))) +(238(539(118(169(357(407(684)(763(960)(830(201)(670))))(150(34)(592(628(34)(637))(856(801)(263)))))(769(412(827(41(203)(401))(633(308)(456)))(36))(964)))(668(158)(365(60)(57))))(814(492(496)(991(669)(2(7(92(369)(446))(30(749)(636)))(732(745)(825(188)(927))))))(468(453(535(594)(918(622(444)(977))(970(912)(542))))(802))(301(993)(106(416(81(627)(262))(325(512)(341)))(570(402)(611(61)(443))))))))(837(258(572(790)(868))(369(153)(353(496(100(656)(928(951)(670)))(895))(284(447(981)(178))(815(738(46)(329))(316(533)(400)))))))(444(214)(608(972(493)(888(261(945(106)(362))(7))(541(822)(169(743)(852)))))(585(326)(986(411(863(623)(543))(406))(786(1(63)(161))(380(555)(700))))))))) +(671(793(527(312(836)(718(695(194)(835(728)(229(397(357)(551))(492(215)(707)))))(540(9(30)(333(543(393)(966))(842(319)(355))))(328(218)(830)))))(721(779)(410(234)(792(885)(268)))))(104(853)(120(439)(544))))(56(119(489(636(610(319)(963(970(490)(905))(657)))(498))(738))(138(147(514(288(913(358(868)(993))(106(753)(200)))(502(34(253)(667))(901(472)(257))))(373(191(927(249)(960))(769(976)(650)))(995(929(142)(156))(6))))(968(322(115(616)(670(469)(795)))(692))(327(892(967(882)(952))(102(796)(489)))(21(2(720)(425))(907(436)(994))))))(998(405(183(477(640(381)(485))(238(263)(417)))(490(207(900)(880))(959)))(350(707)(839(834)(350(164)(213)))))(899(401(520(759(658)(295))(952(568)(862)))(487(17(474)(87))(40)))(692)))))(594(632(489)(296))(597(233(589(461)(473(735(490)(17(566)(720)))(527(767(322)(719))(308(895)(138)))))(730))(37))))) +(33(822(142(902(619)(919(27(798(998(535)(995))(711(121)(302)))(173))(752(490)(820(139(529)(643))(780(402)(231))))))(122))(17(627(830(744)(581(387(417(758)(582))(579(522)(5)))(818(815)(351(510)(757)))))(687))(824)))(186(104(350(263(319(601(366(6)(213))(651))(328(211)(28)))(198(603)(846)))(629))(808(164)(750(461(945(968(230)(519))(1))(951))(492(939(811(611)(392))(559(952)(719)))(743(675(51)(595))(411(282)(300)))))))(724(840(440)(840(638(689(20(523)(193))(258(999)(221)))(629))(675(513)(856(904(650)(986))(564)))))(588(95)(396(476)(37(424(804(772)(698))(86(719)(158)))(96))))))) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/BaumTester.java b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/BaumTester.java new file mode 100644 index 0000000..8cc0446 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/BaumTester.java @@ -0,0 +1,2811 @@ +import static org.junit.Assert.*; +import org.junit.Test; + +/** + * Eine Testklasse für Baumalgorithmen + * + * @author Rainer Helfrich + * @version 02.11.2020 + */ +public class BaumTester +{ + @Test + public void test001() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(0)); + assertEquals(481,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(512)); + assertTrue(ba.enthaelt(596)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(510)); + assertFalse(ba.enthaelt(554)); + assertFalse(ba.enthaelt(287)); + assertFalse(ba.enthaelt(99)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(875)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(974)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(146)); + assertTrue(ba.enthaelt(366)); + assertTrue(ba.enthaelt(367)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(175)); + } + + @Test + public void test002() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(1)); + assertEquals(183,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(711)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(637)); + assertFalse(ba.enthaelt(888)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(692)); + assertTrue(ba.enthaelt(731)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(667)); + assertFalse(ba.enthaelt(549)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(825)); + assertTrue(ba.enthaelt(592)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(416)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(388)); + } + + @Test + public void test003() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(2)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(985)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(374)); + assertFalse(ba.enthaelt(304)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(67)); + assertFalse(ba.enthaelt(972)); + assertFalse(ba.enthaelt(384)); + assertFalse(ba.enthaelt(845)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(353)); + assertTrue(ba.enthaelt(656)); + assertTrue(ba.enthaelt(207)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(163)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(69)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(189)); + } + + @Test + public void test004() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(3)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(132)); + assertFalse(ba.enthaelt(921)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(395)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(141)); + assertTrue(ba.enthaelt(523)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(315)); + assertTrue(ba.enthaelt(849)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(666)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(76)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(585)); + } + + @Test + public void test005() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(4)); + assertEquals(133,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(13)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(236)); + assertFalse(ba.enthaelt(468)); + assertTrue(ba.enthaelt(428)); + assertFalse(ba.enthaelt(312)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(854)); + assertTrue(ba.enthaelt(657)); + assertTrue(ba.enthaelt(232)); + assertTrue(ba.enthaelt(659)); + assertTrue(ba.enthaelt(55)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(127)); + } + + @Test + public void test006() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(5)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(243)); + assertFalse(ba.enthaelt(248)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(285)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(187)); + assertTrue(ba.enthaelt(4)); + assertFalse(ba.enthaelt(497)); + assertTrue(ba.enthaelt(983)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(47)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(116)); + assertTrue(ba.enthaelt(287)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(165)); + assertTrue(ba.enthaelt(905)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(985)); + } + + @Test + public void test007() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(6)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(452)); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(849)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(610)); + assertFalse(ba.enthaelt(73)); + assertTrue(ba.enthaelt(472)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(704)); + assertTrue(ba.enthaelt(828)); + assertTrue(ba.enthaelt(178)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(341)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(916)); + assertTrue(ba.enthaelt(227)); + } + + @Test + public void test008() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(7)); + assertEquals(389,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(772)); + assertFalse(ba.enthaelt(426)); + assertFalse(ba.enthaelt(953)); + assertTrue(ba.enthaelt(319)); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(417)); + assertTrue(ba.enthaelt(883)); + assertTrue(ba.enthaelt(657)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(80)); + assertFalse(ba.enthaelt(183)); + assertFalse(ba.enthaelt(318)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(412)); + assertFalse(ba.enthaelt(145)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(572)); + assertTrue(ba.enthaelt(208)); + } + + @Test + public void test009() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(8)); + assertEquals(159,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(746)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(850)); + assertFalse(ba.enthaelt(267)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(1009)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(166)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(25)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(709)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(853)); + assertTrue(ba.enthaelt(628)); + assertTrue(ba.enthaelt(202)); + } + + @Test + public void test010() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(9)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(993)); + assertTrue(ba.enthaelt(904)); + assertFalse(ba.enthaelt(211)); + assertTrue(ba.enthaelt(845)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(544)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(852)); + assertFalse(ba.enthaelt(65)); + assertTrue(ba.enthaelt(805)); + assertTrue(ba.enthaelt(224)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(604)); + assertTrue(ba.enthaelt(273)); + assertTrue(ba.enthaelt(161)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(590)); + } + + @Test + public void test011() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(10)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(895)); + assertTrue(ba.enthaelt(344)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(181)); + assertFalse(ba.enthaelt(661)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(54)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(690)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(185)); + assertFalse(ba.enthaelt(657)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(907)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(348)); + } + + @Test + public void test012() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(11)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(42)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(650)); + assertTrue(ba.enthaelt(61)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(1013)); + assertFalse(ba.enthaelt(368)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(559)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(987)); + assertTrue(ba.enthaelt(582)); + assertTrue(ba.enthaelt(845)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(656)); + } + + @Test + public void test013() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(12)); + assertEquals(171,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(146)); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(114)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(51)); + assertFalse(ba.enthaelt(399)); + assertFalse(ba.enthaelt(43)); + assertTrue(ba.enthaelt(595)); + assertTrue(ba.enthaelt(831)); + assertFalse(ba.enthaelt(259)); + assertTrue(ba.enthaelt(960)); + assertTrue(ba.enthaelt(919)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(394)); + assertTrue(ba.enthaelt(466)); + assertTrue(ba.enthaelt(459)); + assertTrue(ba.enthaelt(539)); + } + + @Test + public void test014() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(13)); + assertEquals(135,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(870)); + assertFalse(ba.enthaelt(978)); + assertFalse(ba.enthaelt(871)); + assertFalse(ba.enthaelt(669)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(480)); + assertTrue(ba.enthaelt(449)); + assertFalse(ba.enthaelt(380)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(436)); + assertTrue(ba.enthaelt(120)); + assertTrue(ba.enthaelt(433)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(993)); + } + + @Test + public void test015() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(14)); + assertEquals(101,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(583)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(157)); + assertFalse(ba.enthaelt(170)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(458)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(727)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(155)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test016() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(15)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(796)); + assertFalse(ba.enthaelt(842)); + assertFalse(ba.enthaelt(853)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(736)); + assertFalse(ba.enthaelt(76)); + assertFalse(ba.enthaelt(325)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(483)); + assertTrue(ba.enthaelt(190)); + assertTrue(ba.enthaelt(590)); + assertTrue(ba.enthaelt(16)); + assertTrue(ba.enthaelt(534)); + assertTrue(ba.enthaelt(762)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(775)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(760)); + } + + @Test + public void test017() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(16)); + assertEquals(95,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(745)); + assertTrue(ba.enthaelt(293)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(180)); + assertFalse(ba.enthaelt(188)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(356)); + assertFalse(ba.enthaelt(973)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(54)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(520)); + assertTrue(ba.enthaelt(429)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(194)); + } + + @Test + public void test018() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(17)); + assertEquals(315,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(837)); + assertTrue(ba.enthaelt(543)); + assertFalse(ba.enthaelt(696)); + assertFalse(ba.enthaelt(307)); + assertTrue(ba.enthaelt(140)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(405)); + assertFalse(ba.enthaelt(178)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(418)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(997)); + assertTrue(ba.enthaelt(534)); + } + + @Test + public void test019() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(18)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(709)); + assertFalse(ba.enthaelt(22)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(892)); + assertFalse(ba.enthaelt(176)); + assertFalse(ba.enthaelt(680)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(198)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(917)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(98)); + assertTrue(ba.enthaelt(521)); + assertTrue(ba.enthaelt(586)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(197)); + } + + @Test + public void test020() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(19)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(471)); + assertFalse(ba.enthaelt(742)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(682)); + assertFalse(ba.enthaelt(336)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(895)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(495)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(853)); + } + + @Test + public void test021() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(20)); + assertEquals(279,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(439)); + assertTrue(ba.enthaelt(687)); + assertFalse(ba.enthaelt(216)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(516)); + assertTrue(ba.enthaelt(335)); + assertFalse(ba.enthaelt(703)); + assertTrue(ba.enthaelt(132)); + assertTrue(ba.enthaelt(630)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(606)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(422)); + assertFalse(ba.enthaelt(43)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(410)); + assertTrue(ba.enthaelt(235)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test022() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(21)); + assertEquals(215,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(310)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(474)); + assertFalse(ba.enthaelt(123)); + assertTrue(ba.enthaelt(824)); + assertFalse(ba.enthaelt(756)); + assertFalse(ba.enthaelt(829)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(755)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(662)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(195)); + assertTrue(ba.enthaelt(365)); + assertTrue(ba.enthaelt(889)); + } + + @Test + public void test023() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(22)); + assertEquals(107,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(821)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(884)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(545)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(435)); + assertFalse(ba.enthaelt(493)); + assertFalse(ba.enthaelt(823)); + assertFalse(ba.enthaelt(355)); + assertTrue(ba.enthaelt(276)); + assertTrue(ba.enthaelt(84)); + assertTrue(ba.enthaelt(265)); + assertTrue(ba.enthaelt(140)); + assertTrue(ba.enthaelt(529)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(724)); + assertTrue(ba.enthaelt(352)); + } + + @Test + public void test024() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(23)); + assertEquals(207,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(268)); + assertFalse(ba.enthaelt(332)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(666)); + assertTrue(ba.enthaelt(36)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(537)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(941)); + assertTrue(ba.enthaelt(665)); + assertTrue(ba.enthaelt(967)); + assertTrue(ba.enthaelt(667)); + assertTrue(ba.enthaelt(684)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(800)); + } + + @Test + public void test025() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(24)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(197)); + assertFalse(ba.enthaelt(983)); + assertFalse(ba.enthaelt(470)); + assertFalse(ba.enthaelt(487)); + assertTrue(ba.enthaelt(44)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(714)); + assertFalse(ba.enthaelt(623)); + assertTrue(ba.enthaelt(18)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(864)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(488)); + } + + @Test + public void test026() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(25)); + assertEquals(247,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(999)); + assertTrue(ba.enthaelt(173)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(892)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(919)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(4)); + assertFalse(ba.enthaelt(462)); + assertFalse(ba.enthaelt(877)); + assertFalse(ba.enthaelt(568)); + assertTrue(ba.enthaelt(834)); + assertTrue(ba.enthaelt(382)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(575)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(528)); + } + + @Test + public void test027() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(26)); + assertEquals(179,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(626)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(365)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(366)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(900)); + assertTrue(ba.enthaelt(496)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(391)); + assertFalse(ba.enthaelt(801)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(310)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(262)); + assertTrue(ba.enthaelt(513)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(403)); + } + + @Test + public void test028() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(27)); + assertEquals(209,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(627)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(364)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(173)); + assertFalse(ba.enthaelt(257)); + assertFalse(ba.enthaelt(277)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(896)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(706)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(480)); + assertTrue(ba.enthaelt(926)); + assertTrue(ba.enthaelt(832)); + assertTrue(ba.enthaelt(271)); + } + + @Test + public void test029() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(28)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(942)); + assertTrue(ba.enthaelt(924)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(528)); + assertFalse(ba.enthaelt(495)); + assertFalse(ba.enthaelt(262)); + assertFalse(ba.enthaelt(413)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(230)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(758)); + assertTrue(ba.enthaelt(91)); + assertTrue(ba.enthaelt(995)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(62)); + } + + @Test + public void test030() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(29)); + assertEquals(71,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(846)); + assertFalse(ba.enthaelt(828)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(456)); + assertFalse(ba.enthaelt(424)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(908)); + assertFalse(ba.enthaelt(200)); + assertFalse(ba.enthaelt(463)); + assertFalse(ba.enthaelt(246)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(553)); + assertTrue(ba.enthaelt(223)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(222)); + assertTrue(ba.enthaelt(806)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(10)); + } + + @Test + public void test031() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(30)); + assertEquals(109,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(154)); + assertFalse(ba.enthaelt(1000)); + assertTrue(ba.enthaelt(355)); + assertFalse(ba.enthaelt(960)); + assertFalse(ba.enthaelt(301)); + assertFalse(ba.enthaelt(94)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(440)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(71)); + assertFalse(ba.enthaelt(44)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(752)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(122)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(923)); + assertTrue(ba.enthaelt(689)); + } + + @Test + public void test032() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(31)); + assertEquals(87,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(866)); + assertTrue(ba.enthaelt(304)); + assertFalse(ba.enthaelt(623)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(761)); + assertTrue(ba.enthaelt(206)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(769)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(622)); + assertTrue(ba.enthaelt(61)); + assertTrue(ba.enthaelt(409)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(30)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(868)); + assertTrue(ba.enthaelt(36)); + } + + @Test + public void test033() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(32)); + assertEquals(521,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(211)); + assertFalse(ba.enthaelt(231)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(324)); + assertTrue(ba.enthaelt(851)); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(15)); + assertFalse(ba.enthaelt(223)); + assertTrue(ba.enthaelt(553)); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(419)); + assertFalse(ba.enthaelt(90)); + assertFalse(ba.enthaelt(221)); + assertFalse(ba.enthaelt(670)); + assertTrue(ba.enthaelt(876)); + assertFalse(ba.enthaelt(902)); + } + + @Test + public void test034() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(33)); + assertEquals(59,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(617)); + assertFalse(ba.enthaelt(253)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(190)); + assertFalse(ba.enthaelt(779)); + assertFalse(ba.enthaelt(994)); + assertFalse(ba.enthaelt(941)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(351)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(230)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(705)); + } + + @Test + public void test035() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(34)); + assertEquals(107,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(238)); + assertFalse(ba.enthaelt(35)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(137)); + assertTrue(ba.enthaelt(243)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(422)); + assertFalse(ba.enthaelt(930)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(251)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(206)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(79)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(384)); + assertTrue(ba.enthaelt(665)); + } + + @Test + public void test036() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(35)); + assertEquals(93,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(413)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(427)); + assertFalse(ba.enthaelt(660)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(191)); + assertTrue(ba.enthaelt(93)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(700)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test037() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(36)); + assertEquals(175,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(833)); + assertFalse(ba.enthaelt(408)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(559)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(281)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(920)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(726)); + assertFalse(ba.enthaelt(659)); + assertFalse(ba.enthaelt(786)); + assertFalse(ba.enthaelt(876)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(901)); + assertTrue(ba.enthaelt(260)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(782)); + } + + @Test + public void test038() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(37)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(947)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(185)); + assertTrue(ba.enthaelt(255)); + assertFalse(ba.enthaelt(684)); + assertTrue(ba.enthaelt(393)); + assertTrue(ba.enthaelt(88)); + assertFalse(ba.enthaelt(633)); + assertFalse(ba.enthaelt(220)); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(686)); + assertFalse(ba.enthaelt(579)); + assertTrue(ba.enthaelt(501)); + assertTrue(ba.enthaelt(616)); + assertTrue(ba.enthaelt(389)); + assertTrue(ba.enthaelt(285)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(253)); + } + + @Test + public void test039() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(38)); + assertEquals(129,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(572)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(116)); + assertFalse(ba.enthaelt(524)); + assertFalse(ba.enthaelt(569)); + assertFalse(ba.enthaelt(1)); + assertFalse(ba.enthaelt(794)); + assertFalse(ba.enthaelt(300)); + assertFalse(ba.enthaelt(865)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(408)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(154)); + assertTrue(ba.enthaelt(734)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(284)); + assertTrue(ba.enthaelt(628)); + } + + @Test + public void test040() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(39)); + assertEquals(281,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(848)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(878)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(38)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(634)); + assertFalse(ba.enthaelt(577)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(300)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(476)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(851)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(244)); + assertTrue(ba.enthaelt(401)); + } + + @Test + public void test041() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(40)); + assertEquals(117,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(517)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(382)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(733)); + assertTrue(ba.enthaelt(847)); + assertFalse(ba.enthaelt(741)); + assertFalse(ba.enthaelt(868)); + assertFalse(ba.enthaelt(785)); + assertTrue(ba.enthaelt(544)); + assertTrue(ba.enthaelt(302)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(449)); + assertTrue(ba.enthaelt(620)); + assertTrue(ba.enthaelt(465)); + assertTrue(ba.enthaelt(587)); + } + + @Test + public void test042() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(41)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(287)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(225)); + assertFalse(ba.enthaelt(224)); + assertTrue(ba.enthaelt(994)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(488)); + assertFalse(ba.enthaelt(746)); + assertTrue(ba.enthaelt(179)); + assertTrue(ba.enthaelt(1)); + assertTrue(ba.enthaelt(903)); + assertTrue(ba.enthaelt(522)); + assertTrue(ba.enthaelt(407)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(156)); + } + + @Test + public void test043() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(42)); + assertEquals(157,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(608)); + assertTrue(ba.enthaelt(375)); + assertFalse(ba.enthaelt(689)); + assertFalse(ba.enthaelt(856)); + assertTrue(ba.enthaelt(139)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(887)); + assertFalse(ba.enthaelt(481)); + assertFalse(ba.enthaelt(256)); + assertFalse(ba.enthaelt(182)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(114)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(744)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(362)); + assertTrue(ba.enthaelt(755)); + } + + @Test + public void test044() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(43)); + assertEquals(347,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(357)); + assertFalse(ba.enthaelt(718)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(58)); + assertFalse(ba.enthaelt(313)); + assertFalse(ba.enthaelt(530)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(402)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(751)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(220)); + assertFalse(ba.enthaelt(835)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(859)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(237)); + } + + @Test + public void test045() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(44)); + assertEquals(459,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(126)); + assertFalse(ba.enthaelt(328)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(597)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(747)); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(93)); + assertFalse(ba.enthaelt(866)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(228)); + assertTrue(ba.enthaelt(241)); + assertTrue(ba.enthaelt(335)); + assertTrue(ba.enthaelt(257)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(498)); + assertTrue(ba.enthaelt(366)); + } + + @Test + public void test046() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(45)); + assertEquals(187,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(916)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(361)); + assertFalse(ba.enthaelt(635)); + assertFalse(ba.enthaelt(991)); + assertTrue(ba.enthaelt(308)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(203)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(992)); + assertTrue(ba.enthaelt(72)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(357)); + assertTrue(ba.enthaelt(535)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(526)); + assertTrue(ba.enthaelt(483)); + } + + @Test + public void test047() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(46)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(174)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(522)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(578)); + assertTrue(ba.enthaelt(157)); + assertTrue(ba.enthaelt(830)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(307)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(23)); + } + + @Test + public void test048() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(47)); + assertEquals(81,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(763)); + assertFalse(ba.enthaelt(697)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(516)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(331)); + assertFalse(ba.enthaelt(602)); + assertFalse(ba.enthaelt(952)); + assertFalse(ba.enthaelt(928)); + assertTrue(ba.enthaelt(794)); + assertTrue(ba.enthaelt(342)); + assertTrue(ba.enthaelt(551)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(532)); + assertTrue(ba.enthaelt(86)); + assertTrue(ba.enthaelt(217)); + assertTrue(ba.enthaelt(921)); + assertTrue(ba.enthaelt(115)); + assertTrue(ba.enthaelt(32)); + } + + @Test + public void test049() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(48)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(394)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(400)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(569)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(1008)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(902)); + assertTrue(ba.enthaelt(41)); + assertFalse(ba.enthaelt(631)); + assertFalse(ba.enthaelt(927)); + assertTrue(ba.enthaelt(790)); + assertTrue(ba.enthaelt(464)); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(203)); + assertTrue(ba.enthaelt(774)); + } + + @Test + public void test050() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(49)); + assertEquals(73,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(942)); + assertFalse(ba.enthaelt(310)); + assertFalse(ba.enthaelt(44)); + assertFalse(ba.enthaelt(536)); + assertFalse(ba.enthaelt(512)); + assertTrue(ba.enthaelt(257)); + assertFalse(ba.enthaelt(219)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(474)); + assertTrue(ba.enthaelt(21)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(358)); + assertFalse(ba.enthaelt(651)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(309)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(502)); + } + + @Test + public void test051() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(50)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(199)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(721)); + assertFalse(ba.enthaelt(396)); + assertFalse(ba.enthaelt(318)); + assertFalse(ba.enthaelt(625)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(324)); + assertFalse(ba.enthaelt(913)); + assertTrue(ba.enthaelt(869)); + assertTrue(ba.enthaelt(541)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(937)); + assertTrue(ba.enthaelt(837)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(843)); + assertTrue(ba.enthaelt(236)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(752)); + } + + @Test + public void test052() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(51)); + assertEquals(437,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(352)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(708)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(281)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(410)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(555)); + assertFalse(ba.enthaelt(1004)); + assertFalse(ba.enthaelt(768)); + assertFalse(ba.enthaelt(774)); + assertTrue(ba.enthaelt(491)); + assertTrue(ba.enthaelt(589)); + assertFalse(ba.enthaelt(360)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(871)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(918)); + } + + @Test + public void test053() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(52)); + assertEquals(209,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(933)); + assertFalse(ba.enthaelt(77)); + assertFalse(ba.enthaelt(844)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(208)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(171)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(44)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(488)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(574)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(150)); + } + + @Test + public void test054() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(53)); + assertEquals(151,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(254)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(119)); + assertFalse(ba.enthaelt(605)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(738)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(27)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(1003)); + assertFalse(ba.enthaelt(971)); + assertFalse(ba.enthaelt(283)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(159)); + assertTrue(ba.enthaelt(505)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(126)); + } + + @Test + public void test055() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(54)); + assertEquals(311,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(619)); + assertTrue(ba.enthaelt(583)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(436)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(587)); + assertTrue(ba.enthaelt(880)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(225)); + assertFalse(ba.enthaelt(460)); + assertFalse(ba.enthaelt(501)); + assertFalse(ba.enthaelt(286)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(589)); + assertFalse(ba.enthaelt(773)); + assertTrue(ba.enthaelt(912)); + assertTrue(ba.enthaelt(671)); + assertTrue(ba.enthaelt(245)); + assertTrue(ba.enthaelt(145)); + } + + @Test + public void test056() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(55)); + assertEquals(93,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(232)); + assertFalse(ba.enthaelt(504)); + assertFalse(ba.enthaelt(951)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(575)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(255)); + assertFalse(ba.enthaelt(913)); + assertFalse(ba.enthaelt(592)); + assertFalse(ba.enthaelt(649)); + assertTrue(ba.enthaelt(897)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(128)); + assertTrue(ba.enthaelt(228)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(497)); + assertTrue(ba.enthaelt(317)); + assertTrue(ba.enthaelt(269)); + } + + @Test + public void test057() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(56)); + assertEquals(499,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(557)); + assertFalse(ba.enthaelt(863)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(116)); + assertFalse(ba.enthaelt(841)); + assertTrue(ba.enthaelt(683)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(783)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(87)); + assertTrue(ba.enthaelt(983)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(354)); + assertFalse(ba.enthaelt(155)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(725)); + assertTrue(ba.enthaelt(786)); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(1009)); + } + + @Test + public void test058() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(57)); + assertEquals(243,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(1004)); + assertTrue(ba.enthaelt(633)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(998)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(365)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(517)); + assertTrue(ba.enthaelt(242)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(337)); + assertTrue(ba.enthaelt(347)); + assertTrue(ba.enthaelt(133)); + } + + @Test + public void test059() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(58)); + assertEquals(875,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(665)); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(490)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(975)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(789)); + assertFalse(ba.enthaelt(625)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(818)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(566)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(886)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(463)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(84)); + } + + @Test + public void test060() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(59)); + assertEquals(251,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(81)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(998)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(1000)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(570)); + assertFalse(ba.enthaelt(104)); + assertTrue(ba.enthaelt(495)); + assertFalse(ba.enthaelt(584)); + assertFalse(ba.enthaelt(560)); + assertTrue(ba.enthaelt(623)); + assertFalse(ba.enthaelt(1005)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(360)); + assertTrue(ba.enthaelt(630)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(469)); + } + + @Test + public void test061() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(60)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(432)); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(998)); + assertTrue(ba.enthaelt(9)); + assertFalse(ba.enthaelt(940)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(951)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(392)); + assertTrue(ba.enthaelt(226)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(350)); + assertTrue(ba.enthaelt(799)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(836)); + } + + @Test + public void test062() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(61)); + assertEquals(85,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(192)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(869)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(3)); + assertTrue(ba.enthaelt(634)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(785)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(414)); + assertTrue(ba.enthaelt(579)); + } + + @Test + public void test063() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(62)); + assertEquals(221,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(251)); + assertFalse(ba.enthaelt(138)); + assertTrue(ba.enthaelt(803)); + assertFalse(ba.enthaelt(280)); + assertFalse(ba.enthaelt(62)); + assertFalse(ba.enthaelt(665)); + assertFalse(ba.enthaelt(429)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(656)); + assertTrue(ba.enthaelt(463)); + assertFalse(ba.enthaelt(131)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(26)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(167)); + assertTrue(ba.enthaelt(399)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(944)); + assertTrue(ba.enthaelt(625)); + } + + @Test + public void test064() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(63)); + assertEquals(115,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(690)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(525)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(28)); + assertFalse(ba.enthaelt(622)); + assertFalse(ba.enthaelt(270)); + assertFalse(ba.enthaelt(731)); + assertTrue(ba.enthaelt(38)); + assertTrue(ba.enthaelt(479)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(24)); + assertTrue(ba.enthaelt(754)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(289)); + } + + @Test + public void test065() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(64)); + assertEquals(513,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(579)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(598)); + assertFalse(ba.enthaelt(303)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(776)); + assertFalse(ba.enthaelt(522)); + assertTrue(ba.enthaelt(323)); + assertFalse(ba.enthaelt(168)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(922)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(113)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(866)); + } + + @Test + public void test066() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(65)); + assertEquals(79,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(441)); + assertTrue(ba.enthaelt(976)); + assertFalse(ba.enthaelt(797)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(159)); + assertFalse(ba.enthaelt(305)); + assertFalse(ba.enthaelt(486)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(216)); + assertTrue(ba.enthaelt(696)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(225)); + } + + @Test + public void test067() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(66)); + assertEquals(145,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(588)); + assertFalse(ba.enthaelt(860)); + assertTrue(ba.enthaelt(451)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(634)); + assertFalse(ba.enthaelt(154)); + assertTrue(ba.enthaelt(146)); + assertFalse(ba.enthaelt(581)); + assertFalse(ba.enthaelt(778)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(580)); + assertFalse(ba.enthaelt(685)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(106)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(173)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(249)); + assertTrue(ba.enthaelt(244)); + } + + @Test + public void test068() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(67)); + assertEquals(653,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(950)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(543)); + assertTrue(ba.enthaelt(161)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(135)); + assertTrue(ba.enthaelt(119)); + assertTrue(ba.enthaelt(379)); + assertFalse(ba.enthaelt(9)); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(634)); + assertTrue(ba.enthaelt(215)); + assertFalse(ba.enthaelt(345)); + assertTrue(ba.enthaelt(326)); + assertFalse(ba.enthaelt(948)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(803)); + assertTrue(ba.enthaelt(463)); + assertTrue(ba.enthaelt(212)); + } + + @Test + public void test069() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(68)); + assertEquals(231,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(343)); + assertFalse(ba.enthaelt(195)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(377)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(643)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(771)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(198)); + } + + @Test + public void test070() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(69)); + assertEquals(241,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(982)); + assertFalse(ba.enthaelt(326)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(71)); + assertFalse(ba.enthaelt(494)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(915)); + assertTrue(ba.enthaelt(100)); + assertFalse(ba.enthaelt(215)); + assertFalse(ba.enthaelt(48)); + assertFalse(ba.enthaelt(5)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(908)); + assertTrue(ba.enthaelt(451)); + assertTrue(ba.enthaelt(258)); + assertTrue(ba.enthaelt(473)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(734)); + } + + @Test + public void test071() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(70)); + assertEquals(147,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(803)); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(464)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(439)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(494)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(113)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(644)); + assertTrue(ba.enthaelt(537)); + assertTrue(ba.enthaelt(471)); + assertTrue(ba.enthaelt(70)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(581)); + } + + @Test + public void test072() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(71)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(675)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(105)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(328)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(466)); + assertFalse(ba.enthaelt(572)); + assertTrue(ba.enthaelt(499)); + assertFalse(ba.enthaelt(218)); + assertTrue(ba.enthaelt(518)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(32)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(152)); + assertTrue(ba.enthaelt(19)); + } + + @Test + public void test073() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(72)); + assertEquals(231,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(908)); + assertTrue(ba.enthaelt(138)); + assertFalse(ba.enthaelt(1012)); + assertFalse(ba.enthaelt(189)); + assertTrue(ba.enthaelt(745)); + assertFalse(ba.enthaelt(799)); + assertTrue(ba.enthaelt(922)); + assertTrue(ba.enthaelt(595)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(31)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(348)); + assertTrue(ba.enthaelt(850)); + assertTrue(ba.enthaelt(162)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(388)); + assertTrue(ba.enthaelt(694)); + } + + @Test + public void test074() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(73)); + assertEquals(191,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(92)); + assertFalse(ba.enthaelt(929)); + assertTrue(ba.enthaelt(312)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(529)); + assertFalse(ba.enthaelt(567)); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(788)); + assertTrue(ba.enthaelt(487)); + assertTrue(ba.enthaelt(330)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(77)); + assertTrue(ba.enthaelt(624)); + assertTrue(ba.enthaelt(722)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(215)); + } + + @Test + public void test075() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(74)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(561)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(230)); + assertFalse(ba.enthaelt(40)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(624)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(394)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(951)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(364)); + assertTrue(ba.enthaelt(293)); + assertTrue(ba.enthaelt(58)); + assertTrue(ba.enthaelt(798)); + assertTrue(ba.enthaelt(51)); + } + + @Test + public void test076() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(75)); + assertEquals(63,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(251)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(214)); + assertFalse(ba.enthaelt(963)); + assertFalse(ba.enthaelt(921)); + assertTrue(ba.enthaelt(278)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(302)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(640)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(419)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(385)); + } + + @Test + public void test077() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(76)); + assertEquals(265,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(59)); + assertTrue(ba.enthaelt(384)); + assertFalse(ba.enthaelt(286)); + assertTrue(ba.enthaelt(195)); + assertFalse(ba.enthaelt(432)); + assertTrue(ba.enthaelt(591)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(867)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(981)); + assertFalse(ba.enthaelt(32)); + assertFalse(ba.enthaelt(782)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(804)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(129)); + assertTrue(ba.enthaelt(483)); + assertTrue(ba.enthaelt(372)); + } + + @Test + public void test078() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(77)); + assertEquals(211,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(520)); + assertFalse(ba.enthaelt(832)); + assertTrue(ba.enthaelt(98)); + assertFalse(ba.enthaelt(240)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(237)); + assertFalse(ba.enthaelt(873)); + assertFalse(ba.enthaelt(672)); + assertFalse(ba.enthaelt(269)); + assertTrue(ba.enthaelt(115)); + assertFalse(ba.enthaelt(493)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(766)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(519)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(114)); + } + + @Test + public void test079() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(78)); + assertEquals(77,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(274)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(175)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(191)); + assertFalse(ba.enthaelt(640)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(950)); + assertTrue(ba.enthaelt(14)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(402)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(747)); + } + + @Test + public void test080() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(79)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(89)); + assertTrue(ba.enthaelt(366)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(825)); + assertFalse(ba.enthaelt(289)); + assertFalse(ba.enthaelt(1016)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(326)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(239)); + assertTrue(ba.enthaelt(139)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(286)); + } + + @Test + public void test081() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(80)); + assertEquals(577,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(821)); + assertFalse(ba.enthaelt(446)); + assertTrue(ba.enthaelt(748)); + assertFalse(ba.enthaelt(400)); + assertTrue(ba.enthaelt(505)); + assertFalse(ba.enthaelt(898)); + assertTrue(ba.enthaelt(10)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(222)); + assertFalse(ba.enthaelt(977)); + assertTrue(ba.enthaelt(555)); + assertTrue(ba.enthaelt(870)); + assertFalse(ba.enthaelt(845)); + assertTrue(ba.enthaelt(795)); + assertTrue(ba.enthaelt(12)); + assertTrue(ba.enthaelt(233)); + assertFalse(ba.enthaelt(731)); + } + + @Test + public void test082() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(81)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(508)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(770)); + assertFalse(ba.enthaelt(1010)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(15)); + assertTrue(ba.enthaelt(418)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(299)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(768)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(629)); + assertTrue(ba.enthaelt(844)); + } + + @Test + public void test083() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(82)); + assertEquals(393,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(560)); + assertFalse(ba.enthaelt(646)); + assertTrue(ba.enthaelt(558)); + assertFalse(ba.enthaelt(8)); + assertFalse(ba.enthaelt(683)); + assertFalse(ba.enthaelt(805)); + assertTrue(ba.enthaelt(668)); + assertTrue(ba.enthaelt(434)); + assertTrue(ba.enthaelt(483)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(137)); + assertTrue(ba.enthaelt(239)); + assertFalse(ba.enthaelt(747)); + assertTrue(ba.enthaelt(583)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(717)); + } + + @Test + public void test084() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(83)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(805)); + assertFalse(ba.enthaelt(725)); + assertFalse(ba.enthaelt(434)); + assertTrue(ba.enthaelt(289)); + assertFalse(ba.enthaelt(330)); + assertTrue(ba.enthaelt(130)); + assertFalse(ba.enthaelt(876)); + assertFalse(ba.enthaelt(812)); + assertFalse(ba.enthaelt(989)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(594)); + assertTrue(ba.enthaelt(673)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(940)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test085() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(84)); + assertEquals(123,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(332)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(197)); + assertTrue(ba.enthaelt(188)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(59)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(200)); + assertTrue(ba.enthaelt(265)); + assertFalse(ba.enthaelt(320)); + assertTrue(ba.enthaelt(969)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(190)); + assertTrue(ba.enthaelt(664)); + assertFalse(ba.enthaelt(1010)); + assertTrue(ba.enthaelt(340)); + assertTrue(ba.enthaelt(679)); + assertTrue(ba.enthaelt(909)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(416)); + } + + @Test + public void test086() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(85)); + assertEquals(425,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(406)); + assertFalse(ba.enthaelt(372)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(108)); + assertFalse(ba.enthaelt(158)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(581)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(692)); + assertFalse(ba.enthaelt(127)); + assertTrue(ba.enthaelt(593)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(492)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(90)); + assertTrue(ba.enthaelt(457)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(209)); + assertTrue(ba.enthaelt(180)); + } + + @Test + public void test087() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(86)); + assertEquals(43,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(247)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(117)); + assertFalse(ba.enthaelt(733)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(530)); + assertFalse(ba.enthaelt(363)); + assertFalse(ba.enthaelt(827)); + assertFalse(ba.enthaelt(995)); + assertFalse(ba.enthaelt(926)); + assertTrue(ba.enthaelt(294)); + assertTrue(ba.enthaelt(759)); + assertTrue(ba.enthaelt(972)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(450)); + } + + @Test + public void test088() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(87)); + assertEquals(579,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(1017)); + assertFalse(ba.enthaelt(557)); + assertTrue(ba.enthaelt(742)); + assertFalse(ba.enthaelt(95)); + assertFalse(ba.enthaelt(748)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(612)); + assertFalse(ba.enthaelt(131)); + assertTrue(ba.enthaelt(433)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(739)); + assertTrue(ba.enthaelt(831)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(368)); + assertFalse(ba.enthaelt(674)); + assertTrue(ba.enthaelt(889)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(13)); + assertTrue(ba.enthaelt(350)); + } + + @Test + public void test089() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(88)); + assertEquals(229,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(37)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(642)); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(38)); + assertFalse(ba.enthaelt(859)); + assertTrue(ba.enthaelt(324)); + assertFalse(ba.enthaelt(475)); + assertTrue(ba.enthaelt(793)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(480)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(466)); + assertTrue(ba.enthaelt(984)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(721)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(517)); + } + + @Test + public void test090() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(89)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(686)); + assertFalse(ba.enthaelt(84)); + assertFalse(ba.enthaelt(210)); + assertFalse(ba.enthaelt(541)); + assertTrue(ba.enthaelt(775)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(133)); + assertTrue(ba.enthaelt(578)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(750)); + assertFalse(ba.enthaelt(295)); + assertFalse(ba.enthaelt(19)); + assertTrue(ba.enthaelt(278)); + assertTrue(ba.enthaelt(189)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(511)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(39)); + } + + @Test + public void test091() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(90)); + assertEquals(329,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(698)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(467)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(897)); + assertTrue(ba.enthaelt(533)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(538)); + assertFalse(ba.enthaelt(142)); + assertFalse(ba.enthaelt(667)); + assertTrue(ba.enthaelt(783)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(48)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(478)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(834)); + } + + @Test + public void test092() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(91)); + assertEquals(87,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(77)); + assertTrue(ba.enthaelt(369)); + assertFalse(ba.enthaelt(596)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(899)); + assertFalse(ba.enthaelt(901)); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(785)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(98)); + assertTrue(ba.enthaelt(996)); + assertTrue(ba.enthaelt(356)); + assertTrue(ba.enthaelt(688)); + assertTrue(ba.enthaelt(746)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(92)); + assertTrue(ba.enthaelt(238)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(105)); + } + + @Test + public void test093() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(92)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(185)); + assertFalse(ba.enthaelt(447)); + assertFalse(ba.enthaelt(401)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(535)); + assertFalse(ba.enthaelt(886)); + assertFalse(ba.enthaelt(775)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(988)); + assertTrue(ba.enthaelt(67)); + assertTrue(ba.enthaelt(678)); + assertTrue(ba.enthaelt(50)); + assertTrue(ba.enthaelt(144)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(636)); + assertTrue(ba.enthaelt(633)); + assertTrue(ba.enthaelt(296)); + assertTrue(ba.enthaelt(947)); + } + + @Test + public void test094() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(93)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(965)); + assertFalse(ba.enthaelt(826)); + assertFalse(ba.enthaelt(551)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(11)); + assertFalse(ba.enthaelt(497)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(177)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(816)); + assertTrue(ba.enthaelt(26)); + assertTrue(ba.enthaelt(80)); + assertTrue(ba.enthaelt(824)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(37)); + assertTrue(ba.enthaelt(943)); + assertTrue(ba.enthaelt(363)); + } + + @Test + public void test095() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(94)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(313)); + assertTrue(ba.enthaelt(769)); + assertFalse(ba.enthaelt(74)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(473)); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(663)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(783)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(531)); + assertTrue(ba.enthaelt(625)); + assertTrue(ba.enthaelt(186)); + assertTrue(ba.enthaelt(442)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(999)); + } + + @Test + public void test096() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(95)); + assertEquals(79,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(630)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(926)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(214)); + assertTrue(ba.enthaelt(63)); + assertFalse(ba.enthaelt(329)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(934)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(256)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(441)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(333)); + } + + @Test + public void test097() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(96)); + assertEquals(141,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(98)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(15)); + assertFalse(ba.enthaelt(931)); + assertFalse(ba.enthaelt(265)); + assertFalse(ba.enthaelt(226)); + assertTrue(ba.enthaelt(639)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(150)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(281)); + assertTrue(ba.enthaelt(510)); + assertTrue(ba.enthaelt(428)); + assertTrue(ba.enthaelt(631)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(12)); + } + + @Test + public void test098() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(97)); + assertEquals(139,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(889)); + assertFalse(ba.enthaelt(987)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(33)); + assertFalse(ba.enthaelt(485)); + assertFalse(ba.enthaelt(482)); + assertFalse(ba.enthaelt(946)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(227)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(763)); + assertTrue(ba.enthaelt(63)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(57)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(401)); + assertTrue(ba.enthaelt(301)); + assertTrue(ba.enthaelt(214)); + assertTrue(ba.enthaelt(30)); + } + + @Test + public void test099() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(98)); + assertEquals(169,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(714)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(597)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(760)); + assertTrue(ba.enthaelt(610)); + assertFalse(ba.enthaelt(411)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(127)); + assertFalse(ba.enthaelt(541)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(379)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(568)); + assertTrue(ba.enthaelt(156)); + assertTrue(ba.enthaelt(882)); + assertTrue(ba.enthaelt(952)); + assertTrue(ba.enthaelt(102)); + } + + @Test + public void test100() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(99)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(307)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(273)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(697)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(387)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(396)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(28)); + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Baumalgorithmen.java b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Baumalgorithmen.java new file mode 100644 index 0000000..896223e --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Baumalgorithmen.java @@ -0,0 +1,130 @@ + +/** + * Führt verschiedene Algorithmen auf Binärbäumen aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Baumalgorithmen +{ + /** + * Die Wurzel des Baums, mit dem der Algorithmus durchgeführt werden soll + */ + protected Binaerbaum wurzel; + + /** + * Erzeugt ein neues Algorithmen-Objekt + * @param wurzel Die Wurzel des Baums, der verarbeitet werden soll + */ + public Baumalgorithmen(Binaerbaum wurzel) + { + this.wurzel = wurzel; + } + + /** + * Zeigt den Baum auf der Konsole an. + */ + public void baumAnzeigen() + { + if (wurzel != null) + { + System.out.println(wurzel.daten); + baumAnzeigen(wurzel.links, "", true); + baumAnzeigen(wurzel.rechts, "", false); + } + } + + private void baumAnzeigen(Binaerbaum b, String indent, boolean left) + { + System.out.print(indent); + System.out.print(left ? "\u251C " : "\u2514 "); + if (b != null) + { + System.out.println(b.daten); + if (b.links != null || b.rechts != null) + { + indent += (left ? "\u2502 " : " "); + baumAnzeigen(b.links, indent, true); + baumAnzeigen(b.rechts, indent, false); + } + } + else + { + System.out.println(""); + } + } + + /** + * Gibt die Tiefe des Baums zurück + * @return Die Tiefe des Baums, gezählt ab der Wurzel + */ + public int tiefe() + { + return tiefe(wurzel); + } + + /** + * Gibt die Tiefe eines Baums zurück + * @param b Der Baum, dessen Tiefe bestimmt werden soll + * @return Die Tiefe des Baums, gezählt ab b + */ + private int tiefe(Binaerbaum b) + { + if (b == null) + { + return 0; + } + return 1 + Math.max(tiefe(b.links), tiefe(b.rechts)); + } + + /** + * Gibt die Anzahl der Knoten im Baums zurück + * @return Die Anzahl aller Knoten im Baum + */ + public int anzahl() + { + return anzahl(wurzel); + } + + /** + * Gibt die Anzahl der Knoten in einem Baums zurück + * @param b Der Baum, in dem die Knoten gezählt werden sollen + * @return Die Anzahl der Knoten, die sich von b an im Baum befinden (inklusive b) + */ + private int anzahl(Binaerbaum b) + { + if (b == null) + { + return 0; + } + return 1 + anzahl(b.links) + anzahl(b.rechts); + } + + /** + * Prüft, ob sich ein Wert im Baum befindet + * @param wert Der zu suchende Wert + * @return true, wenn ein Knoten den Wert enthält; false sonst + */ + public boolean enthaelt(T wert) + { + return enthaelt(wurzel, wert); + } + + /** + * Prüft, ob sich ein Wert in b oder darunter befindet + * @param b Der Baum, in dem der Wert gesucht werden soll + * @return true, wenn b oder einer seiner Kindknoten den Wert enthält; false sonst + */ + private boolean enthaelt(Binaerbaum b, T wert) + { + if (b == null) + { + return false; + } + if (b.daten.equals(wert)) + { + return true; + } + return enthaelt(b.links, wert) || enthaelt(b.rechts, wert); + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Binaerbaum.java b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/README.TXT b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/README.TXT new file mode 100644 index 0000000..ee5db68 Binary files /dev/null and b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/README.TXT differ diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Testbaeume.java b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Testbaeume.java new file mode 100644 index 0000000..a7f9076 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/Testbaeume.java @@ -0,0 +1,75 @@ +import java.util.ArrayList; +import java.io.FileReader; +import java.io.BufferedReader; +import java.util.ArrayList; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Liest Testbäume aus einer Datei aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Testbaeume +{ + /** + * Die aus der Datei eingelesenen Bäume + */ + static ArrayList> baeume; + + private static void readFile() + { + try + { + FileReader fileReader = new FileReader("testfaelle.txt"); + BufferedReader bufferedReader = new BufferedReader(fileReader); + baeume = new ArrayList>(); + String line = null; + while ((line = bufferedReader.readLine()) != null) { + AtomicInteger ai = new AtomicInteger(0); + Binaerbaum b = parse(line.toCharArray(), ai); + baeume.add(b); + } + bufferedReader.close(); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + baeume = null; + } + } + + private static Binaerbaum parse(char[] c, AtomicInteger s) + { + int anfang = s.incrementAndGet(); + while(c[s.get()] != '(' && c[s.get()] != ')') + { + s.incrementAndGet(); + } + String tmp = new String(c, anfang, s.get()-anfang); + int value = Integer.parseInt(tmp); + Binaerbaum ergebnis = new Binaerbaum(value); + if (c[s.get()] == '(') + { + ergebnis.links = parse(c, s); + s.incrementAndGet(); + ergebnis.rechts = parse(c, s); + s.incrementAndGet(); + } + return ergebnis; + } + + /** + * Gibt einen der Testbäume aus der Datei zurück + * @param nummer Die Nummer des Baums + * @return Den gewünschten Baum, wenn die Nummer gültig ist; null sonst + */ + public static Binaerbaum getTestBaum(int nummer) + { + if (baeume == null) + readFile(); + if (nummer >= 0 && nummer < baeume.size()) + return baeume.get(nummer); + return null; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/package.bluej b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/package.bluej new file mode 100644 index 0000000..4713e61 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/package.bluej @@ -0,0 +1,65 @@ +#BlueJ package file +dependency1.from=BaumTester +dependency1.to=Baumalgorithmen +dependency1.type=UsesDependency +dependency2.from=BaumTester +dependency2.to=Testbaeume +dependency2.type=UsesDependency +dependency3.from=Testbaeume +dependency3.to=Binaerbaum +dependency3.type=UsesDependency +dependency4.from=Baumalgorithmen +dependency4.to=Binaerbaum +dependency4.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=816 +editor.fx.0.x=972 +editor.fx.0.y=111 +objectbench.height=93 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8 +package.editor.height=393 +package.editor.width=649 +package.editor.x=866 +package.editor.y=209 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=4 +package.numTargets=4 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Binaerbaum +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=170 +target1.y=60 +target2.height=50 +target2.name=Baumalgorithmen +target2.showInterface=false +target2.type=ClassTarget +target2.width=160 +target2.x=300 +target2.y=130 +target3.height=50 +target3.name=BaumTester +target3.showInterface=false +target3.type=UnitTestTargetJunit4 +target3.width=100 +target3.x=460 +target3.y=210 +target4.height=50 +target4.name=Testbaeume +target4.showInterface=false +target4.type=ClassTarget +target4.width=100 +target4.x=79 +target4.y=264 diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/testfaelle.txt b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/testfaelle.txt new file mode 100644 index 0000000..7c0595c --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/02_baumalgorithmen_loes/testfaelle.txt @@ -0,0 +1,100 @@ +(366(518(665(284(101(853(360(314(190(465(386(162)(241))(459(197)(861)))(654(427(528)(255))(351(835)(533))))(445(394)(717(311)(530(253)(429)))))(756))(749(236(53(339(469(265)(695))(642(837)(192)))(860))(215))(618(340)(547(201(410)(811(37)(331)))(567)))))(130))(685(76(105(293(837)(262))(3(766)(875(161)(773(65(505)(939))(351(33)(379))))))(94))(301(90(820(166(63(931(73)(590))(936(439)(190)))(990(270(240)(807))(795)))(194(919(694)(244(430)(243)))(924)))(468(420(668)(282(73(966)(860))(270(400)(608))))(914(467)(402(915(547)(648))(96(715)(255))))))(259(870(672(733)(854(327(778)(811))(150)))(629(398(837)(333(203)(270)))(104(749(730)(534))(59(668)(940)))))(769(130)(366(408)(674)))))))(512(869(507(359(823(542)(799(713(910(693)(435))(319(663)(736)))(198)))(992))(682))(73(49)(872)))(715(628)(297))))(274(532(581(418(844)(325))(747(420(97(426(902)(991(682(440)(307))(361(493)(173))))(82(739)(645)))(493(837(182)(720(245)(817(498)(968))))(831(302)(939(429(907)(473))(914)))))(859(111(802(413(303)(291))(432(883(20)(891))(560(263)(932))))(874(85(679(130)(79))(2(761)(596)))(959(675(66)(894))(847(899)(364)))))(448))))(844(446)(690(377)(561))))(615(266)(757(612)(509(374)(641(998(367(40(223(598)(359))(129(700)(312)))(539(534(127)(583))(351(551)(108))))(276))(111(860(406(706(561)(854))(298))(680))(919))))))))(830(154(760(719(29)(9(395(471(575(625)(960(743(939)(344))(499)))(413(186(60(224)(691))(951(821)(906)))(320)))(640(555(914)(820))(910(657(725(105)(879))(896(538)(806)))(572(13(175)(254))(362(276)(664))))))(118(129(973(588)(843(20)(212(115)(2))))(300))(215(15(322)(317(144(646)(549))(411)))(50(274(452(129)(879))(454(473)(758)))(568(13(766)(542))(981(129)(211))))))))(170))(900(132(614(589(526)(550))(379(947(268(789(787(255)(889))(234))(258(112(9)(669))(593(871)(191))))(248))(451(474(35(112(436)(165))(930(550)(739)))(339(271)(745(56)(905))))(790(981)(562(33(737)(533))(648(530)(140)))))))(488))(136)))(123(832(708(637(395)(156))(360))(71(498(989(10(571)(964(248(460)(751(848)(925)))(626)))(758))(190(357(999(155)(944(210(223)(239))(687(125)(817))))(395))(593(170(119)(73(269(614)(685))(84)))(185(672)(587(80)(633))))))(198(495(107)(91(487(163(178)(628(935)(376)))(977(513)(648)))(925)))(546(595)(908(440)(557(74)(328(318(304)(292))(883(209)(198)))))))))(459(108)(358(450(817)(161))(233(503(321)(365(295)(392(811)(18(807(785)(268))(821)))))(757))))))) +(796(145(612(934(49(576)(126(436(825(199)(657))(983(245)(286)))(942(105)(545))))(42(514(577)(575(8(157)(275))(617(534)(266))))(714(783(935(907)(964))(88(376)(912)))(653(24(199)(221))(244(526)(50))))))(829(186(24(829(855(529)(692))(429(635)(202)))(932(306)(120)))(368(495)(41(566)(512(591)(478)))))(4(650(339(8(605)(714))(203(926)(92)))(480(778(367)(273))(414(4)(191))))(102(889(558(413)(379))(159(931)(866)))(514)))))(743(286(669)(277(800(656)(842))(576(680(913(429)(355))(445(51)(681)))(311))))(194)))(273(760(978(506)(240(273(592(409(521)(731))(937(463)(941)))(284))(839(932)(502(996(396)(90))(444)))))(56(620(37(872)(131(377(950)(185))(416)))(170(22(834(726)(208))(247(839)(205)))(597(103(154)(349))(810))))(109)))(886(39)(9(499(597(217)(763(530(174)(699))(257(904)(185))))(54(556(310(258)(475))(382(66)(187)))(995(958)(993(604)(14)))))(502(827)(808(131)(428(580(983)(342))(388)))))))) +(683(388(163(757)(113(798(174)(612(46(595)(66))(674(828)(41))))(837(948)(258(646(887)(334))(441(959)(15))))))(744(332(589)(551(671(661)(186(43)(947)))(681(301(229)(228))(419(887)(865)))))(207)))(954(649(258(654(185(288)(577(9)(344)))(661))(251))(435(410(565(15(469)(812))(665))(33))(917)))(770(69(985(916)(629(968)(719)))(656(628(39(481)(590))(210(705)(518)))(785(914)(995(221)(913)))))(861(435(98(150(51)(562))(343(706)(189)))(607))(219(404(741(216)(249))(423(258)(347)))(904(417(770)(210))(691(104)(997)))))))) +(163(852(819(592(619(567(235(402)(879(960)(406(195)(948))))(669(976(604(382)(740))(284))(611(837)(69(328)(239)))))(271))(870(664(295)(145(255)(36)))(876(194)(712(318(31)(915))(351)))))(475(45)(991)))(335(743(755)(441))(814(763(950(321(350)(387(947(374)(845))(38)))(849(23(344)(652(250)(120)))(988(691(304)(951))(110))))(705(909(916(751)(189))(747(450(764)(834))(394(517)(35))))(585(864)(9(673(898)(179))(76(160)(447))))))(731(392(446)(381))(540(656(864(0)(367(693)(629)))(305(0(125)(838))(535(938)(768))))(178(488(744(415)(328))(595))(422(371(6)(235))(884(7)(398)))))))))(946(361(346)(711(14(616(523(666(232(648)(755))(728))(870(901(690)(411))(864(527)(334))))(349(958)(27(805(192)(926))(986))))(311))(105(73(250)(466))(829(43(210(547(955)(206))(842(637)(520)))(690(984(704)(385))(715)))(277)))))(192(118)(909(177)(488(363(453(752(711(252)(343))(616(279)(315)))(62(250(718)(464))(853)))(280))(86(183(905)(319))(545(502(153(524)(28))(234(654)(538)))(207(202(196)(925))(751(611)(540)))))))))) +(428(369(333(668(626(728(715(766(113)(716))(358(119)(581)))(792(313(214)(593))(205)))(32(858(988(487)(810))(621(586)(659)))(252(958(882)(514))(464(532)(840)))))(290(185(646(134(972)(477))(24(20)(865)))(399))(639(98(814)(127))(285))))(598(719)(631(631(694(304(356)(372))(964))(295(295(351)(625))(950(934)(653))))(471))))(956(283)(918(849(594(297(774(27)(354))(217(657)(825)))(77(634(185)(308))(111(4)(151))))(944(344)(375(186(396)(331))(177(727)(9)))))(133))))(99(272(200(740(632)(544(484)(958(464(67)(779))(948(915)(280)))))(477(421(114)(232))(67(277)(374))))(481))(441(952)(513(805(383)(271(610(991(943)(145))(439))(614(404(885)(884))(854))))(55))))) +(954(577(3(685(175(779)(365))(287(144)(836(706(119(312)(761))(557(73)(706)))(131(270(116)(381))(780)))))(216))(325(688(803(795(820)(525(572(4)(406))(757(601)(139))))(398))(528(589(176)(624(174(924)(770))(665)))(175(131)(373(254(835)(548))(110)))))(695(329(432)(136(60(100(202)(814))(507(520)(797)))(760(51)(834(867)(706)))))(568))))(734(449(453(865(372(14(423(909)(290))(489(357)(387)))(769))(131(165(83(3)(125))(62(892)(339)))(984(948(401)(423))(211(174)(525)))))(881))(491(850(4)(984(661)(297(312(741)(482))(326))))(141(768(319)(362(514)(961(78)(74))))(429(163(214(626)(417))(955(995)(411)))(774(262(570)(615))(701(753)(589)))))))(429(438(800(925)(168(983(992(905)(385))(362))(985)))(787))(675(764)(437(426(113)(38(884(13)(940))(752(625)(850))))(754(404)(45(677)(371)))))))) +(606(112(79(954)(960(122(347)(738(153(282(599)(182(702)(486)))(625(947(281)(667))(908(737)(30))))(547(894(892(645)(443))(909(3)(250)))(382(510(87)(553))(527(891)(916))))))(513(122(687(590(644)(378(496)(371)))(384(990(33)(526))(245(28)(810))))(466))(867))))(368(44(945)(632))(609(491(319(623(672)(43(292(275)(338))(40(268)(814))))(227))(936))(438))))(230(982(227)(924))(472(274(834(642)(916(266)(910)))(39))(379(505(863(557(492(353(564)(821))(33))(903(916(976)(447))(866)))(181(461(472)(769))(471)))(831(557(779)(836))(791(595(552)(443))(424))))(409(157(449(833(371(734)(276))(253(14)(773)))(981(853(792)(647))(0)))(999(660(110)(106(904)(231)))(178(126(941)(259))(369))))(69(263(565(454(473)(83))(828(438)(494)))(249(889(822)(405))(732(470)(264))))(453(200(341)(829(952)(810)))(381(78)(822(640)(995)))))))))) +(911(409(461(415)(644(343(732(308)(141))(219))(897(809(70)(642(978(138(879(224)(511(639)(526)))(744(799(189)(993))(976(946)(792))))(723(388)(125(744)(850))))(427(56(117(402)(708(547)(664)))(179(572(615)(248))(13(590)(296))))(645(413(742(584)(789))(208(771)(254)))(601(84(191)(813))(955(871)(166)))))))(313))))(599(187)(279)))(988(300(428(234(90(964(998)(707))(383(586(754(413(130)(204))(204))(439(53)(481(369(761)(90))(790(7)(27)))))(797(651(371)(490(543(735)(681))(298)))(982))))(848(301)(195)))(320))(178(776(474(407(794)(926(766(991(543(883)(3))(452(725)(134)))(14(79)(254(189)(389))))(479(847(752(427)(229))(131(866)(13)))(56))))(159(760(980(696)(107(54)(624(247)(944))))(6(637)(641)))(699)))(993(188(93(854(51)(217(980(791)(542))(501)))(143(398(439(871)(102))(615(983)(268)))(651(17)(754))))(784(781(482(163)(568(233)(416)))(392(982(892)(797))(377(648)(516))))(920(691(654(685)(75))(539))(134(47)(334(398)(829))))))(829(174(509(692(882)(18(581)(772)))(68))(699(836(792)(243))(558(831)(935(435)(193)))))(712))))(42(677(447(116(976(326)(840(354)(300(677)(729))))(736(383(184(317)(823))(408(89)(806)))(175(556)(922))))(875(196(931)(848(286(175)(274))(428(625)(905))))(103(661(574(713)(900))(394(562)(583)))(915))))(84(940(153)(482))(561(775(890(539(164)(416))(290(763)(984)))(5))(888))))(270(52(788(412(179)(201(388)(480(585)(231))))(259(463)(542(918)(412(453)(615)))))(313))(139)))))(389(964(60(636)(456(688(33)(293(946)(310(872(915(749)(657))(544(40)(984)))(851(557(258)(322))(271(63)(619))))))(632(64(959(615(501)(760(716)(853)))(666(360(427)(5))(566(120)(108))))(234(7(834)(320(781)(838)))(169(144(798)(625))(129(969)(647)))))(154))))(378(99)(287(198(565(105(960(865(851)(354))(342))(638(742(229)(493))(731)))(165(331(317(449)(192))(838))(421(585(669)(552))(233(938)(966)))))(630))(937))))(984(785(202)(192(319(370(663)(14))(438(704(702)(299(991(474)(591))(792(27)(188))))(596)))(803)))(811))))) +(789(549(347(66)(232(216)(334(182)(771(733)(213)))))(807(391(900(181)(983(290(105)(717(802)(875(18)(266(832)(179)))))(944(487(168(221(36)(79))(513(531)(955)))(532))(397(834(826(216)(937))(761))(667(441(870)(464))(67(457)(623)))))))(403(134)(698)))(592(222(425(952)(111))(483(626(25(202)(359(735(95)(950))(428(898)(334))))(495))(239)))(21(768)(224(122(958(980(480(333)(265))(191(7)(974)))(197))(643))(900(552(454(628(925)(864))(422(345)(883)))(459))(639)))))))(215(987(991)(473))(699(657(369(69(666(555(907(220(94)(769))(765(878)(666)))(866(516(874)(942))(955(75)(348))))(117(621(193(670)(94))(343(388)(950)))(269(272(667)(787))(87(684)(161)))))(997(613)(658(853)(680(801(479)(117))(381(100)(866))))))(298))(29(993)(268(135(115(994(554)(787))(709))(56))(889))))(582(343)(698))))) +(78(894(236(464)(309(794(437(372)(581))(604(967(426(157)(869))(411(808)(462)))(361(500(698)(610))(711(184)(755)))))(623(224(102)(360(572(35)(492))(698)))(781(916(150(750)(434))(296))(33(562)(293(286)(7)))))))(334(974(756)(757(272)(867(866(772)(881(776)(845)))(470(147)(950(939)(295))))))(52(64(783(689)(848(710)(702(315)(234))))(659))(553(261(355(730)(375(945)(477)))(391(974(579)(747))(257(662)(578))))(472)))))(781(562(312(370(643(904(223)(218(273)(576)))(933(151(110)(185))(418(680)(805))))(213(766(980)(479(976)(952)))(860)))(303(383(994)(744))(117)))(477))(88(709(182)(224(431)(514)))(205(445(684(593(864)(920(184)(590)))(714(664(890)(466))(70)))(578))(161(686)(43)))))) +(625(138(24(127)(87(799(704(45(53(762(592)(632(920)(338)))(26(134(8)(482))(441)))(133))(520(326(508(762(997)(197))(209(870)(273)))(890(275(700)(789))(9)))(712(325)(968(46(210)(645))(815(185)(127))))))(711(121(742)(591(675(143(800)(138))(633))(558(157)(651))))(758(642(309(430)(276(967)(339)))(425))(295(230)(158(642(98)(146))(353))))))(917)))(792(49(249(953(481(183(753(150)(154(551)(29)))(448(589(229)(760))(83(749)(860))))(131))(91(797(135(888(470)(964))(922(762)(823)))(971))(964)))(223(152)(352(83(590(300)(861))(933(331(640)(817))(502(56)(884))))(825))))(955(767(435(343(249(170(20)(367))(27(428)(907)))(913))(87(929)(328)))(74(116(441(3(877)(146))(835(74)(135)))(829(932(263)(64))(944)))(639(794)(613(27)(815(728)(666))))))(361(184(365)(996(632(20)(69(13)(949)))(922(489(471)(348))(866(337)(627)))))(425(180(438(219)(566))(414(66(811)(674))(397)))(894(551(529(603)(462))(821(710)(544)))(900(698)(43(356)(687))))))))(321(377(200(215)(144))(784(301)(350(349)(100(725(438(366)(154))(839))(866(197(390)(902))(564))))))(729(883(737)(490(409)(118)))(366(420)(444(311(936(629(348)(205))(256(52)(904)))(461(616(47)(111))(471)))(347)))))))(460(721(848(335)(198(972(362)(934))(484(157)(656))))(431(351)(808)))(211(597(996(486(888)(429(937(139)(372(951)(951)))(500(525(954(527)(733))(888(383)(247)))(849(662)(900(941)(344))))))(903))(664))(681(250(557(681(886(694)(57(99)(660(972)(981))))(755(453(786(263)(257))(666))(818)))(62))(36(690)(721)))(27(598(478)(739))(62(968(284(954(699(592)(703))(654(816)(279)))(791))(238))(909))))))) +(406(829(52(802(122(453)(306(227)(255(601(917(640(648)(92))(878))(878))(163(343)(710)))))(830(642(812(899(875(418)(308(739)(436)))(3(186(176)(964))(937)))(829))(893(199(62)(92(388(999)(153))(114(282)(164))))(664)))(186(897(306(926)(268(369(203)(793))(454(691)(749))))(986(702(875)(414(738)(868)))(112(427(61)(334))(587))))(480(534(307(401(489)(415))(641))(37))(743(148(491)(646(38)(947)))(267(889(91)(82))(421)))))))(316))(219(235(770(183)(525(870)(447)))(134(190(796)(215))(887)))(149)))(129(934(774(646(189(430)(181(746)(163)))(750(966(411(761)(48))(151(678(459)(898(200)(87)))(122(144(821)(563))(197))))(663(710)(455(990(778(924)(343))(141(528)(67)))(810(76(888)(887))(776(111)(724)))))))(236(294(494(515(366(793(506)(851))(977(319)(577)))(394))(542))(477(15(133(492(969)(554))(313))(543(367(969)(279))(719(658)(617))))(621(0(49)(845(422)(441)))(153))))(33(115(859(18)(642(274)(48(538)(237))))(628(598)(158(745(461)(599))(696))))(650))))(876(406(931(501(274)(32(370(850(399)(724))(431(810)(376)))(441(103(918)(580))(627(259)(688)))))(444(74(643)(577(2)(799)))(572(71)(27))))(971))(856(83(110)(838(69(804)(94))(897)))(582(322(364(665)(671))(849))(364(840(485(840(185)(242))(801))(231(965(857)(670))(475(888)(381))))(961(822(762(764)(838))(519(723)(402)))(634(434(39)(742))(43(84)(110)))))))))(289(571(177(274)(823))(984(118(921)(884(408(38)(685(48(172)(393))(571(64)(434))))(47(310)(237))))(484(693(207(487(582(867)(93))(855))(56))(755))(934(665(364(600)(852(620)(625)))(393(203(734)(525))(935(470)(656))))(872)))))(899)))) +(219(539(56(513(197(904(65)(576))(252(473)(757(720(869)(574))(908))))(69))(901(115(307(671(429)(897(919)(326)))(91(452(891)(898))(993(179)(950))))(835(925(586)(838(88)(934)))(419(965)(643(70)(83)))))(247(658(866)(281(36(257)(978))(865(753)(27))))(990(262(853)(17(294)(917)))(651(866(365)(998))(419(249)(595)))))))(237(822)(470(394(606)(886(579(243(296)(255))(579))(956)))(953))))(344(508(343(515)(792(283(647(124)(611))(81(548(85)(194))(837(938)(785))))(477(265)(185(499(232)(585))(459(419)(215))))))(156(242)(966)))(117(513(107(798(603(207(759)(129))(120(650)(279)))(85(402)(907)))(911(45(208(960)(14))(732(891)(220)))(927)))(798(240(980(325)(434(223)(205)))(227(813(595)(354))(983(498)(782))))(226(51)(437(873)(255(959)(310))))))(469(545)(172(618(273)(466(808)(205(328)(755))))(835(124(286)(419))(243(742(831)(801))(417(10)(860))))))))) +(869(433(663(632(826(438)(568(22(292(183)(384))(135))(717)))(10))(618(60(291(623)(46(243(208)(665))(298)))(27(25)(563)))(493)))(956(20)(384(720(804(50)(802(214(817)(561))(865(895)(517))))(399(971(715)(872(417)(2)))(902)))(484(11(86)(130))(768(583(95(377)(465))(590))(357(943)(463)))))))(907(32(120(412(227)(138(893)(15(728(436)(300))(940(140)(668)))))(718(401)(777(106(120(940)(508))(912(753)(223)))(698(936(150)(742))(297(993)(701))))))(448(41)(357)))(742(246)(657(697(510(239(289(879)(456))(474))(631(971(970)(958))(733)))(541(449)(736(328(283)(394))(482(293)(788)))))(611(630(206)(713(999)(695(948)(401))))(723(827(919(584)(541))(286(985)(797)))(179))))))) +(784(843(954(100(546(420(21(286)(257))(488(49)(207)))(194))(523(869)(748(106(373)(657))(781))))(599))(948(961(332(105(159(884)(174))(985(759)(407)))(857(329(678)(33))(161(410)(716))))(972))(145(79(73(60)(945))(155(255)(123(518)(103))))(459))))(888(601(356(219)(59))(110(563)(102)))(983(826(727(979(862(776)(148))(807(663)(469)))(447))(926(152(613)(31))(255)))(842(662(965(401)(20(973)(888)))(667(149(774)(844))(519(332)(99))))(142(92(142(860)(526))(657(458)(557)))(128(591)(364(687)(943)))))))) +(216(85(100(562(557(730(989(657)(342))(704(985)(723)))(772(636)(203)))(655))(237(644)(917(839(676)(52(229)(412)))(486(567(128)(484))(757(531)(84))))))(16(169(545)(259))(813(970(894(29(238)(971))(313(426)(855)))(721(335)(586(609)(687))))(213(591(744(856)(18))(489))(708(355(551)(826))(210(515)(890)))))))(231(291(199(970(121(882(800)(652))(719))(953))(590(152)(229(928(200)(677))(776(211)(384)))))(902(775)(200(425)(199(543(117)(197))(762(390)(639))))))(410(953)(190(230)(310(141(534(283)(702))(760(647)(359)))(872)))))) +(285(23(900(846(994(378)(147(430(630(890)(890))(644(855)(887)))(902(522)(846(194)(193)))))(335))(812))(851(466(612(869)(534(750(115)(22))(418)))(53(54(783(862(696)(398))(103(386)(73)))(236(776(164)(213))(293(474)(774))))(828(105)(366(357(920)(322))(732(229)(80))))))(650)))(441(287(729(153(398(761)(597(565(741)(729))(136(526)(316))))(807))(516(461)(85)))(429(561)(767(641(520)(204(833)(100)))(107(370(110)(186(872)(220)))(785(122)(422(751)(293)))))))(358(806)(312)))) +(942(681(997(799)(615(618(595(78(677)(753(948(851)(552(885)(209(355)(502))))(315)))(440(85)(111)))(223(899(616(97)(174(260)(811)))(128(311(789)(974(474(519)(80))(870(596)(899))))(697)))(503(739(263(163)(586(762)(470(342)(207))))(355(282(786(693)(933))(90(160)(36)))(234)))(275(774)(444(83(431(381)(543))(458(42)(969)))(146(2)(995)))))))(244(66)(878(398(216)(273))(300(248(743)(64(549(148)(625))(304(699(801)(993))(1(734)(863)))))(509(676(316)(622(136(828)(140))(910)))(149(551(966)(693(794)(235)))(146))))))))(505(931(116(59(337(69(232(190)(936(702(146)(584))(297)))(84))(705))(346))(990))(86(7(999(637(255)(531(966(39(657)(309))(475(946)(290)))(921(137)(207(365)(190)))))(606(510)(494)))(736))(290(231(957)(441))(973))))(947(28)(438(605(487)(720(510(521(32)(73))(452))(333(810(343)(149(90(700)(275))(846(129)(279))))(102(332(717(180)(289))(598))(90)))))(731(825(815)(958))(952(566(37)(250(464(824(982)(941))(906(821)(258)))(421(2)(426(804)(763)))))(567)))))))(860(328(737)(572(891(418(869(988)(777(759(442(243)(618(777)(555)))(743))(436)))(380(200(38)(859(681(763(339)(232))(150(19)(79)))(655(623(270)(906))(988(478)(208)))))(279(50)(725))))(922(78(713(205)(769(378)(523)))(174))(533(780(251(614)(11))(152))(817(270(639)(996(773(671)(201))(648(582)(764))))(203(902)(367(313(692)(707))(767(24)(277))))))))(271(954(460)(166))(536(496(30)(68))(795(97(212(209(114(66)(378))(592(258)(304)))(344))(651(220(176(202)(27))(132(295)(14)))(995(534(284)(640))(474))))(533(471(473(860(422)(549))(357(675)(914)))(834))(515)))))))(103(569)(42)))) +(911(832(222(261(538(20(900(227)(332))(215(547(586(585(955(900)(107))(194(855)(294)))(885))(253(966(330(142)(130))(822))(246(272(242)(618))(61))))(490)))(679(725(978)(817(118)(444)))(12(290)(448))))(38))(803))(502(222(238(520)(628))(747(496(195(669(3)(656(593(846(559)(521))(142(755)(276)))(647(714(281)(761))(401))))(989(349)(381(673)(213))))(458))(308(913)(224(940(425(347)(668(638)(917(27)(243))))(68))(358)))))(797(989(85(372(278)(645))(737(917)(640(428(980)(338(551(172)(20))(609(642)(452))))(637(113(864(299)(366))(796(935)(336)))(944)))))(607(451(525)(739(110)(489(994)(44(563)(821(983)(719))))))(606(855)(804(245(335(886(154)(154))(383))(592(308(590)(837))(231(719)(358))))(749(0(686(862)(307))(921))(402(574(110)(375))(270(102)(888))))))))(803(753(47(746)(936(620(568(701(659)(466))(98))(644(807(375)(8))(309(666)(577))))(23(263)(80))))(67(990(934(731(736(657)(98))(325(260)(8)))(679(355(718)(823))(285)))(207(625)(666(568)(913))))(329(128)(890(266)(642)))))(169(717)(534))))))(61(105(610)(577(26(410(364)(261(866(803)(429(571)(658(906(117)(752))(880))))(262(376)(836(283(189(576)(492))(331(419)(421)))(129(92(256)(684))(337))))))(332(741(627(73)(612(411(275(485)(603))(808))(63(645(972)(263))(737(613)(297)))))(867(21)(903(9(32)(965(496)(197)))(805(60(350)(584))(858(799)(314))))))(940(411(174(807(33)(854(224)(429)))(999(431(853)(91))(429(533)(958))))(161(810(672(896)(158))(592))(290)))(790))))(276(96)(983))))(548(431)(877(810)(437(939(732)(420))(208)))))) +(322(40(406(697)(653(334(763(814(289)(135))(293))(102))(58(294(533(727)(347))(712(881)(953)))(257))))(161(385(597(437)(342(580)(748(296)(560))))(165(522(366(863)(552))(77))(423)))(485(11)(515(970(778)(931(923)(111)))(257(524)(176))))))(480(14(765(513(988(88(236)(387))(349))(810))(570(515(962(395)(197))(888(642)(66)))(718(438(816)(561))(738(884)(490)))))(687(687(230(953(84)(526))(925))(520))(918(543(19(850)(226))(222(388)(723)))(294))))(440(758(576(807(696(75)(573))(791))(187(888(598)(934))(166(545)(284))))(528))(144(666)(895(586)(669(853(875)(600))(495))))))) +(367(144(971(360(303)(884(12(481(748)(36(196(29)(545(549)(407)))(850(529)(425(628)(291)))))(449(386(428)(545(75(267)(378))(924(207)(683))))(994(865(72)(701(333)(46)))(520(229(399)(545))(633(893)(317))))))(367(808)(317(742(273(711(569)(733))(529))(54(164(505)(707))(206(745)(449))))(159)))))(250(722(335(395)(251(297(544(918)(929))(787(405)(648(520)(132))))(834)))(774(534(549(96(738(766)(586))(825))(768(160(984)(680))(931(793)(235))))(506))(94(802(446(93(799)(359))(891(916)(806)))(597(257(188)(940))(951(613)(750))))(687(878(384)(705(235)(812)))(312(195(379)(196))(131))))))(189(829(353(126(193)(852))(625(675)(160(584(174)(616))(612(752)(848)))))(252))(103(288(752(108(38(630)(212))(539(382)(751)))(99(936(569)(271))(262)))(185(844(118(411)(700))(217))(247(734)(6(253)(650)))))(821(829(197(370(390)(887))(386))(480(249(149)(77))(127(213)(385))))(449(370(217(892)(452))(368(65)(677)))(2(865(809)(643))(439))))))))(353(478(506(614(438(646(142(675)(959(422)(194)))(482(353(795)(660))(486(842)(622))))(400(793)(192(393)(689))))(961))(797))(175))(727)))(552(379(762)(386))(184(283(759(522(854(431(7(951(815)(410))(190))(464))(456(527(810(467)(354))(421))(619(423(947)(361))(130))))(753))(771))(144(753(15(322(754(487(589)(211))(961(34)(340)))(567(840)(712(315)(793))))(487))(730))(485(641)(83(407(730(407)(491(642)(473)))(590(125(688)(787))(347(567)(833))))(850)))))(953)))) +(320(876(21(68(322)(964(724(72(115(177)(985))(721(460)(126)))(726(73(505)(83))(32)))(48(713(749(403)(703))(313))(71(180(385)(210))(736(4)(588))))))(435(182(803(311(715(456)(552))(364(142)(273)))(600(261(195)(824))(883(275)(975))))(644(790(410(88)(651))(414))(161(897(315)(899))(646(967)(442)))))(148(559(21(168(932)(659))(889(124)(505)))(168(682(19)(613))(182)))(381(365(692(449)(764))(225(545)(204)))(979(960(380)(449))(360))))))(815(693(658)(793(649(390(14(260)(685))(370))(624))(22(8(492)(429))(715(451(556)(724))(800(294)(455))))))(377(674(221(524)(207))(329(678)(164(928(822)(934))(222(929)(590)))))(354))))(750(338(806)(482(518(943(337)(843(203(804)(965))(294(964)(156))))(791(495)(373(375(460)(228))(334(681)(163)))))(537(233(931)(501(291(249)(436))(802)))(872(649(358(954)(219))(364))(588(301)(310))))))(831(217(471(825(24(856)(286))(613(21)(450(773)(453))))(382))(100))(343(666(6(93(550)(867(622)(999)))(962(267)(454(878)(698))))(549(816(302)(317(619)(115)))(746)))(692(173(897)(632(367(662)(622))(552)))(18(211(301)(436(995)(804)))(281))))))) +(592(880(594(847(551(266)(120(574)(864(677(801)(662))(577(897)(84)))))(724))(738(983)(106(779(592)(784(141)(716(841)(504))))(848))))(434(752)(265(34(352(413(877(529)(879))(163(658)(71)))(138))(969(278(382)(300(671)(602)))(410(181(198)(767))(847))))(580(888)(2)))))(240(977(609(257(46)(855(254(59)(39))(877(646(604)(919))(839(913)(533)))))(496))(84))(786(667(55)(749(47(250)(891))(260(994(277(862)(138))(439(816)(938)))(544(481(140)(950))(374)))))(864(693(988)(676))(334(79)(959(217)(877(190(178)(276))(869(704)(124))))))))) +(294(453(659(644)(625(75(687(802(311(562(830(80)(262))(805(512)(649)))(156))(43))(122(675(428(119(24)(667))(519(704)(777)))(430(185)(56(839)(684))))(814(223(931(634)(490))(987))(719))))(220))(504)))(863(446(366)(319(140)(453)))(1(922(226(744)(260(496)(288(269(639(248)(496))(940(820)(82)))(708(501)(331(341)(558))))))(698(967(864)(386(759(225(868)(953))(381))(727)))(822)))(604(182(667)(411(35(474)(138(205(64)(783))(495)))(995(300(103)(691(101)(524)))(451))))(644(125)(760(429(615(42(754)(595))(571))(526))(486(439)(700))))))))(912(761(407)(337(999)(896(206)(656))))(151(675(400(119(784(634)(800(673)(675(541(889)(282))(883(206)(884)))))(796(372(384(424(622)(397))(279(314)(36)))(24(474)(961(942)(409))))(343(683(17)(931(75)(284)))(328(29(525)(133))(5(236)(222))))))(882(697(466(727)(844(932)(555(87)(430))))(155(424(551(219)(924))(460(117)(245)))(321)))(35(665(249(6(482)(24))(454))(319(690(802)(430))(946(78)(338))))(67(597(787(162)(675))(653))(678)))))(784))(607(636(561)(505(630)(805)))(743(256)(87)))))) +(346(966(18(883(832(888)(759(549(782(505)(828))(571(341)(645)))(886(375(950)(506))(335(875)(949)))))(22))(357(44)(553(510(856)(488))(587(830(736(408)(864))(114))(864(354(635)(747))(667(774)(211)))))))(725(969)(166(970)(702(747(226)(340(830(371)(296))(496)))(139(765(688)(910(574)(298)))(739(830(817)(798))(809(359)(500))))))))(125(428(389(987(169)(738(678(422(414)(999))(941(852)(303)))(108(942(281)(277))(773))))(401(999)(559)))(655))(73(471(450(836)(18(253(124)(399(105)(736)))(532(510(243)(699))(575(444)(66)))))(834(784(2(345)(22(469)(6)))(752))(258(692(398)(311))(507))))(952)))) +(667(914(684(859)(730(220)(948)))(910(271)(191(644)(433))))(519(915(45(762(253)(94(314)(576)))(652(233)(73(916(511(682)(135(648)(428)))(598))(744(555)(28(516)(19(69(838(575)(40))(792(657)(600)))(210)))))))(998(729(308(520(698)(442(905(398(117(361)(809))(161))(119))(975(273(576)(919))(432(65)(95(264)(770))))))(560))(717(337)(761(491)(366(96(662(754(619)(579))(144))(679(597(724)(594))(876(522)(288))))(436(688(711(115)(861))(134(708)(170)))(533(546)(821(870)(672))))))))(745(109)(633(895(860(614)(735(256(112)(764))(796(237(390)(368))(917(834)(250)))))(184))(844(887)(346(789)(717(854(173(45)(943))(150))(941))))))))(791(669(799(419(874)(732(362)(225)))(981))(185(844(185(474(192(741)(722))(650(981(130(196)(307))(377))(774)))(33(848)(507(532)(33(328(407)(276))(153)))))(809))(189(393)(528(180(328(571(791)(36(154)(896)))(212(632)(153)))(167))(594(184(440(766(727)(683))(508(810)(675)))(966(537(188)(977))(888(65)(80))))(60(618(105)(290(312)(996)))(441)))))))(35(516)(883(805(920(240(382(684)(762(87(743)(5))(936(19)(190))))(697(321(41)(929(905)(934)))(776(919(957)(276))(267(900)(350)))))(136(431(822(272)(708(426)(653)))(592(743(778)(378))(758(689)(302))))(125(816(308)(332(18)(515)))(263))))(775))(501)))))) +(261(541(634(380)(941(594(171(633)(277(387(550)(52))(443(391)(261))))(510(608)(269)))(349)))(835(610(279(127(977(650(378)(442))(75(496)(891)))(298(95)(268(78)(687))))(403(883(529(346)(934))(497(487)(782)))(119(67)(868))))(890(783(160(620)(450(284)(239)))(16(636(194)(139))(207(535)(599))))(699(188)(901(570(774)(770))(554(144)(555))))))(457)))(701(605(235)(856(681(935(763(941(904)(584))(909))(68(409(832)(111))(823(860)(779))))(516))(83(370(831(471(906)(294))(788(673)(824)))(662(772(59)(624))(825(641)(135))))(762(131(644(280)(83))(603(328)(626)))(153(719(667)(451))(770(422)(245)))))))(984(912)(367(540(428(262(926)(65(505)(442)))(955(833(52)(62))(88(720)(865))))(718(442(65(310)(255))(418))(765(179(745)(43))(329(2)(667)))))(118(780(145(38(577)(460))(476))(281(606(957)(833))(984(262)(581))))(492(40(797(343)(98))(146(513)(642)))(577(730(740)(205))(725(997)(546))))))))) +(410(55(51(490(832)(240(429(150)(916(745(204(691)(932))(548(499)(124)))(155)))(90(638(720)(837(827)(600(792)(321))))(603))))(362))(540(88)(459(935(926)(791(128(868(480(402)(255))(51))(478(753(309)(195))(109)))(423(976(621(769)(842))(94))(875(230(42)(772))(483(706)(492))))))(48))))(634(200(825(804(990(978(896)(979(258)(380(380)(498))))(485(54(314)(410))(470)))(686(381(689)(608(937)(192(134)(591))))(952(363(936(169)(486))(771(251)(16)))(122(849(49)(931))(892(996)(97))))))(749(55(497(839)(774(27(648)(343))(46(53)(730))))(711))(569)))(20(358(833(164(857(612(578)(598))(523(440)(769)))(363))(398(111(719(394)(271))(703(912)(463)))(518)))(215(108(467(567(744)(829))(727(77)(723)))(788(57(741)(186))(226(774)(484))))(946(361)(966(29)(29(589)(534))))))(586(238(482(422(894)(261))(315(435(155)(578))(221(864)(622))))(429(398)(255(468(36)(989))(988(560)(926)))))(534))))(729(258(693(145(707(319(674(921)(194))(944(407)(268)))(837(131)(243(616)(881))))(107(899)(348(596(356)(108))(81(131)(66)))))(683))(996))(111(846)(582))))) +(99(760(785(571(577)(217(137(82)(937(453(48(930(388)(227(302)(687)))(848(99(689)(298))(253(856)(179))))(573(644)(695(244)(892))))(838(618(932(807)(896))(107(379)(228)))(367(692)(359(954(973)(794))(890))))))(329(159(633)(654(342(832(930(670)(194))(743))(641(418)(787)))(170(866(94(307)(173))(924(592)(277)))(82(22(460)(239))(333(965)(726))))))(921(995(895(836(212(176)(801))(637))(206(427(476)(738))(330(984)(470))))(647(837(313(892)(182))(524(176)(613)))(265(258(549)(482))(962(846)(519)))))(145(241(290(130(857)(538))(871(325)(7)))(680(140(205)(38))(97(381)(898))))(460(352)(601)))))))(277(857)(137(476(325(243(156(228(916(764)(602))(968(393)(220)))(805))(362))(875(947)(272(350(984(815)(762))(971(593)(691)))(272))))(799(595)(839)))(422))))(665(894(461)(544(880(888(719)(631(215)(829(714(488(129)(941))(628(169)(722)))(830))))(601(934(958(479)(614))(570(988(223)(503(104)(479)))(522)))(575(580(324(873)(158(81)(855)))(549))(701(113(767(545)(454))(164(282)(49)))(807)))))(238)))(91)))(115(46(641)(825(196(418(307(173(550)(152))(400(48(954(18)(965(485)(576)))(271(355(334)(549))(177)))(335(435)(472(94(932)(155))(215(523)(230))))))(473))(885))(635(365(341(835)(774(707(499)(144(757(691)(704))(534(106)(815))))(912(59(101)(301))(636(144(882)(103))(385(10)(687))))))(868))(516(395(321(472(104)(716(639(4)(497))(993)))(838(114)(131(217(588)(944))(780(889)(449)))))(471(927(76(505(729)(58))(929))(749(748(566)(729))(647(758)(285))))(300)))(733)))))(877(978(308(818(493(884(803(97)(62(395)(940)))(312))(461(526(77(520(48)(590))(906))(456(365(901)(264))(65)))(968)))(273(659(782(281(152(65)(953))(944(772)(75)))(976(55(925)(508))(526)))(827(134(673(309)(518))(696(629)(905)))(251)))(307)))(263))(471(447)(5(97(308)(729))(282))))(966(890)(86(977)(32)))))) +(252(556(259(58)(553))(252(553)(232(286(10(126)(654))(949(515(557)(242))(697(346)(638))))(430(704(806(516)(222))(70))(910(287)(865(848)(419)))))))(687(3(95(405)(888))(14(14(223(573)(551(689)(5)))(542(702)(22(211)(237))))(723)))(262(266(274(700(62)(493(640)(496)))(528(397(40)(245))(954)))(87(474)(427(813(916)(650))(916(841)(575)))))(750)))) +(734(442(130(617(578(626)(752(449(907)(888))(610(118)(316))))(538(231(597)(897(537)(299)))(731(776)(41(672)(511)))))(13))(398(303(972(266)(556(660(351)(638))(458)))(767(887)(353(133(152)(801))(997(856)(957)))))(6(427)(351(902(788)(27(105)(580)))(908(953(689)(465))(312))))))(517(963(20(792(287(566(423)(378))(73(727)(642)))(98(685(171)(69))(923(661)(989))))(436(355)(272)))(744))(91(667(164)(665))(473(70(610(431(127)(902))(84(177)(801)))(115(877(472)(927))(187)))(891(48(694(322)(821))(715))(216(509(513)(17))(896(619)(122)))))))) +(655(558(864(315(611(210)(547))(76(24)(409)))(596))(60(797(274(702(902)(307(800(642)(275))(494(625)(30))))(726))(949))(542)))(564(203(155(11(306)(992))(946(509(813)(645))(918(350(866)(815(357)(867)))(234(443(452)(253))(589(587)(407))))))(148(82(829)(878(61(110)(241))(763)))(198)))(485(111(829)(706(36(448(25)(781(963)(304)))(643(514(128)(709))(791(500)(161))))(460(202(250)(96(206)(405)))(736(65)(553(868)(296))))))(447)))) +(728(760(302(553(753(145)(709(773(337(932)(761))(456(991(317)(912(929(589)(132))(136(893)(192))))(511)))(935(817)(493(546(950)(37(841(811)(936))(355)))(356)))))(849))(991(398(963(324(547(382)(655(704(696(471)(166))(483(795)(146)))(517(462)(665(324)(880)))))(456))(628))(659(7)(669(347(921(653)(660(509(183)(903))(55(697)(251))))(575(318)(830)))(332))))(372(932(994(810(431)(683(137(700)(770(147)(52)))(946)))(336(580(43(954(517)(29))(568))(318(185(677)(107))(586(318)(926))))(108(412(802(33)(128))(173))(834))))(764))(603(60(877(248(613(571(833)(126))(357(290)(333)))(617))(671(384(12(39)(452))(752(137)(561)))(181(288(684)(929))(730(693)(961)))))(866(22(883(312(867)(159))(114))(901(37(956)(619))(190(436)(152))))(504(620)(538(686)(417(31)(758))))))(864)))))(891(369(935(818(949(141(258)(82(98)(99(385)(157(860)(651)))))(997(677(205(959(35)(78))(145(919)(470)))(121))(465)))(946(26(815)(607(298(971(615)(851))(685(892)(541)))(827(956(253)(784))(833(657)(389)))))(352(966(314(53(346)(468))(141(957)(208)))(170(32(873)(985))(511)))(94))))(780(353(609(87(365)(421(103(836)(15))(894(665)(214))))(171(201(441)(682(857)(312)))(259(291)(668(176)(592)))))(269(244(927(672(642)(333))(32))(877))(562(325(62)(875(68)(796)))(530(933)(259(756)(690))))))(595(895(456(543(919(226)(578))(890(158)(379)))(117))(907))(308(202(34(150(807)(241))(590(100)(877)))(980(137)(955(826)(732))))(106(650(929(326)(631))(780))(940))))))(19(1)(998(893(516(140(24(28(900)(149))(926(387)(913)))(484))(106))(789))(689(953)(679)))))(141(718)(500(603(801)(285))(781)))))(376(250(810)(68))(659(99(184)(776(822(553(548(345(181)(571(169(224)(644))(790(575)(939))))(62))(598))(718(283(711(929(678)(519))(628))(762(146(421)(514(289)(602)))(347(135(126)(683))(764(653)(588)))))(804(486(872(523(70)(247))(693))(230(33)(767(629)(956))))(430(48)(13)))))(59(717)(249(211(94(581(26)(424(568)(890)))(162(980(738)(64))(892(563)(879))))(10(623(450(87)(53))(836(981)(705)))(375(658(481)(49))(887))))(798)))))(617(178(728(646)(543(454(95(131)(377(152(406)(54))(654(155)(835))))(787(731(61)(785(354)(215)))(100(10)(692))))(399(569(790(330(351)(218))(868))(681(622)(66)))(443(993(524)(876(741)(557)))(59)))))(388(680(988)(167))(255(761(181(195(250)(903(457)(290)))(374))(352(194(911(972)(331))(2(746)(139)))(914(750(312)(991))(594(744)(773)))))(380))))(730(867)(241(745(933(904(916)(616(398(0)(95))(10(158)(642))))(816))(120(267(931)(466(821(528)(222))(567(376)(668))))(200)))(811(285(1(894)(719(972(379)(650))(422(994)(10))))(239))(120(259)(748(61(521(426)(755))(344(181)(600)))(640)))))))))) +(502(740(856(332(132(113)(964(502(925)(22))(195(997)(705))))(771))(385))(107(790(771(677)(639))(663))(861)))(728(986(362(559(524(720)(458(853)(589)))(450))(21))(993(230(581)(157(206(957)(270))(190(686)(205))))(327(374(769(571)(776))(143))(754(192(215)(393))(827(307)(951))))))(159(731)(924)))) +(79(999(151(586)(56))(631(606)(400(276(881)(748))(952(641(701)(249(281(821)(661))(554)))(881)))))(829(963(946(373)(604(377(805)(372))(828(243(665)(373(342(72)(998))(979(68)(247))))(938(98(802(105)(597))(570))(550)))))(667(468(442)(626(444)(580(337)(553))))(830(597)(151))))(898(58(404(235(325(888(251(574)(961))(687))(28(845(313)(977))(297(638)(240))))(868))(712(410(699)(447))(577(462(786)(870))(423))))(206(437(129(905(711(407)(298))(14))(635(201)(627(226)(135))))(781(646(384)(263))(590(454(77)(235))(145))))(996)))(6)))) +(896(250(11(658(389(504)(159(576(920)(836))(608)))(617(31(997(648)(647))(392(859)(846)))(855(513)(326))))(321(715(446)(929(908)(839(815)(337))))(590(338)(743(7)(446(28)(385))))))(439(838(14(736(256(177)(398))(866(653)(23)))(395))(953))(51)))(229(970(93(380)(999(251(339)(711(915)(300)))(428(472)(810))))(379(392(551)(86(700(593)(546))(788(897)(477))))(385)))(253(98(648)(717(642(196(749)(213))(736(395)(250)))(814(44(223)(990))(249(894)(338)))))(516)))) +(29(594(488(63)(746))(997(110(76(330)(579))(730(965(779(201(95)(14))(80(551)(760)))(577(329)(780)))(616)))(505(784(610(481)(452))(472(533(782)(961))(777)))(623(301(677)(803))(706(261(703)(718))(303(503)(556(618)(747))))))))(612(840(65(588(991(385)(203))(848))(571(301(224(260(518)(321))(222(237)(881)))(763(41(927)(59))(826(16)(249))))(816(209(912(74)(57))(18(343)(378)))(399(694(784)(523))(525(825)(903))))))(901))(729(749(4(329(515(382(80)(183))(25))(495(884(167)(284))(413(151)(864))))(477(603(144)(188(631)(341)))(790(897(334)(473))(1(163)(818)))))(500(299(749(922(601)(775))(751(832)(830)))(405(83)(222)))(33(167(664(340)(920))(163(824)(126)))(581(709)(861(373)(559))))))(568(94(697(229(785(497)(393))(214))(704))(121(969(28(444)(583))(870(254)(618)))(685(159)(284))))(194(22)(26(996(70(122)(769))(987))(464(598(601)(319))(192(912)(166))))))))) +(662(884(946(656(795(367)(60(626(56(704(241(740)(45))(465(122)(207)))(260(708(589)(916))(245)))(593(465(322(753)(630))(448(285)(451)))(481(321(78)(746))(413(145)(477)))))(602(942(217(176(456)(666))(2(503)(253)))(670))(948(510)(587(432(335)(533))(451(743)(224)))))))(376))(40))(868(453(680(795(788(284)(422(1(109)(805(750)(298)))(427)))(674(350(364(613(881)(33))(629))(812(891(135)(886))(263(625)(482))))(740(482)(520(591(821)(224))(774(670)(78))))))(379(101(743(867(548)(429(315)(984)))(267))(767))(827(724(212(516)(8))(229(980)(260(239)(229))))(383(883)(888(12(479)(527))(666))))))(751))(716(573(997(926)(67))(554(461)(3(12(974(840(997)(788))(907))(363))(604(787)(435)))))(550(958(475(968(866)(704(702(357)(59))(313)))(51(355)(119(352(669)(423))(673(389)(56)))))(255(484(316(545(468)(112))(501(649)(513)))(83(33)(542)))(754(343)(950(390)(393(659)(163))))))(736)))))(771(765(521(11)(16(437(352(570(461(608(433)(476))(907(805)(167)))(674))(453))(959(389(861(22)(685(23)(76)))(807(955)(438(32)(133))))(401)))(229(919(152(942)(673(393(391)(330))(213)))(274(408(447(491)(581))(324(26)(526)))(425(88(315)(420))(427))))(838(613(728(584(122)(435))(693(621)(393)))(809))(750(309)(332(772(922)(127))(436(238)(229))))))))(50(350)(312(609)(925(389(781(451(935(311)(368))(377(896)(777)))(811(641)(66)))(437(828)(420(48)(42(853)(938)))))(337(787)(288(487(313)(544))(68(394)(685))))))))(817(496(397(594(930)(119(720(49(785(418)(298))(826(508)(605)))(912(444(16)(411))(227)))(304)))(970))(14(176)(959)))(145(81)(161(895(378)(5(58(839(10)(508(542)(227)))(85))(261)))(616(861)(958(245(934(570(895)(102))(721(125)(311)))(631(544(51)(699))(191(290)(948))))(765(287(411)(202(241)(876)))(62(104)(238(654)(993))))))))))) +(801(628(263(35(303(401(417(942(141)(222))(426(527)(124)))(836(913(853)(773))(688(908)(220))))(430))(306(572(505)(183(888)(880)))(208(92(154)(137(0)(600)))(736(206(888)(450))(326(789)(114))))))(735))(304(942(393(892(984)(507(588(516)(99))(734(784)(999))))(925(446(612(752)(353))(339(730)(676)))(89(231)(685(461)(609)))))(828(268)(76(686(557(499)(177))(77(917)(18)))(266(24(934)(910))(837(226)(895))))))(948(666)(748(198(100)(994(592(637)(434))(253(858)(804))))(433(532(357(83)(145))(635(371)(995)))(144))))))(137(597(929(62(422(717(816)(301(638)(25)))(123))(132))(404))(843))(471(146)(536(896(822)(959(769(172)(284))(853)))(156))))) +(704(294(634(743(365(112(182)(488))(675(586)(822(968)(278))))(809(481(679(389)(765(73(810(782)(989))(286(445)(390)))(51(327(509)(350))(208))))(854(85(760(375(915)(954))(626(168)(243)))(61(83(786)(785))(709)))(73)))(133)))(178))(318(177(501)(316(621(364(447(980)(24))(546))(383(799(854(790(130)(963))(775(657)(30)))(30(222)(614(789)(874))))(630)))(371(710)(792(144(883(273(497)(162))(257(992)(463)))(767(614(324)(371))(566(43)(219))))(992(649(282(900)(797))(844))(462(53)(617(527)(139))))))))(698(272)(177))))(304(197(683(442(533(947(664)(253(212(679(858)(74))(158))(269)))(862(678(177(631(90)(180))(956(748)(755)))(322(373)(451(838)(371))))(792(851(715(302)(179))(609(732)(161)))(213(524(563)(746))(710)))))(264(106(251)(130))(774(285(24)(55(685)(618(783)(621))))(40(329)(244)))))(661(219(615)(808(314)(899(749(933(595)(432))(855(799)(882)))(706(231)(345(614)(238))))))(520)))(986))(997(730)(806(911(495)(292(255(29(379)(243))(473(319(740(719)(49))(697(820)(419)))(173(526)(251(513)(817)))))(13(284(83(602(470)(421))(752(432)(0)))(276(495(536)(675))(150(124)(534))))(510(857(502(721)(476))(649))(922(784)(440(721)(991)))))))(354(938(736(750(196(804(315)(124))(203(502)(810)))(838(416)(346)))(627(401(618(717)(468))(213(703)(163)))(637(101)(428(622)(153)))))(284(972(11(917(902)(317))(561(50)(289)))(597(663(742)(687))(772(688)(32))))(563(618)(38(9(236)(225))(905)))))(22)))))) +(503(796(915(843(514)(392(618(218)(289(733(709)(229))(408)))(206(25(93(680)(891))(391(268)(964)))(66))))(265(889)(157)))(808(302)(727)))(824(403(31(16(314)(465(474(604(6)(414))(294(246)(728)))(718(326)(51))))(832(910(174)(181(38(750)(199))(762(760)(980))))(864(229)(333(493)(391)))))(960(798)(336(437(587(299(294)(41))(349(227)(906)))(371(517(965)(226))(449(500)(51))))(807))))(544(194)(642(620(325(743(829(151)(700))(802(619)(173)))(345(689)(572(540)(28))))(290(675(515(309)(124))(330(847)(385)))(626)))(730(826)(413(797(807)(170(185)(885)))(217(851)(531(548)(493))))))))) +(840(452(552(6(903(632(381)(113(399)(353)))(180(504(121)(825))(605(57)(407))))(840(651)(1(387(358)(755))(520(647)(962)))))(837))(356(759(533(731(160(228)(548))(522(225)(461)))(379(156(667)(777))(438(200)(572))))(211(19(184)(863(928)(237)))(326(221(829)(867))(765(709)(743)))))(446)))(994(332(763(683)(957(821)(313)))(223(362(645(270)(921(232)(281)))(926))(133)))(957(736(851(236(848)(741(706)(90)))(378))(405(989(696)(884(995)(991)))(179(805(420)(464))(49(627)(88)))))(362)))) +(179(734(868(218(212(776(704(477)(639))(237(325)(127)))(821))(449(449(502)(362(680)(613)))(998)))(170))(648(331(736(47(325)(215))(375(134(607)(384))(273)))(517(570(665(93)(752))(826(230)(480)))(814(952(960)(644))(632(139)(675)))))(797(918(761(658(273)(628))(993(585)(874)))(307))(862(680)(138(596)(705))))))(904(144(251(620(467(185(431)(795))(668(398)(398)))(134(929(539)(451))(236(724)(555))))(989(824(562(471)(601))(101(210)(14)))(444(301)(755(127)(384)))))(684(524(676(95(460)(605))(323(717)(269)))(99(243(31)(875))(634)))(977(738(92(828)(581))(478))(340))))(534(584(838(641(516(405)(334))(220))(423(913(140)(593))(271(269)(499))))(594(534(646(475)(358))(252(94)(385)))(697(771)(542(353)(108)))))(744(867(396(225(788)(433))(933(406)(416)))(16(933)(52(78)(290))))(327))))) +(568(749(107(784(197(580(979(980(336)(392))(597(80(101)(315(188)(179)))(941(482)(821(112)(546)))))(745(316(209)(308(582(665)(745))(253(177)(756))))(797(487(403(234)(640))(190))(296))))(632))(537(879(442(236)(58(303(947(684)(262))(704(31)(990)))(543)))(269(276)(632(578(127(319)(409))(113(311)(284)))(964(572(811)(170))(573(932)(446))))))(305(789(70(96(401(592)(151))(76(832)(759)))(352(663(7)(144))(768)))(14(34(457(618)(808))(75(956)(915)))(178(370(189)(409))(938(947)(920)))))(258))))(642(876)(902(735)(710(761(318(236(504(974)(113))(222(96)(616)))(982(577(761)(920))(940(420)(725))))(622(863(578)(291(806)(307)))(527(711)(978(860)(220)))))(191(228(758(745(221)(774))(57(85)(400)))(40))(509(979(28(93)(60))(868))(26)))))))(650(237)(47(502(956(563(630)(48))(30(764(652(327)(282(412)(817)))(456(96(400)(395))(685)))(608(732)(96(659(268)(696))(329)))))(499))(121(392(495(681(759(330(214)(297))(42(826)(18)))(462(939(25)(442))(13(879)(859))))(640(751)(442(855(234)(468))(512(474)(408)))))(51(282)(68)))(730)))))(822(176(180)(691(521(676(830)(81))(897(889(898(10(691(236)(482))(468(304)(218)))(517))(725))(87)))(833(84(456(79(656(101)(293(433)(880)))(0(91(915)(280))(118)))(213(696(816(385)(582))(955(460)(622)))(298(667(868)(590))(859(984)(301)))))(932(621(69(543(89)(959))(678))(932(995)(367(585)(912))))(243(768)(970(890(397)(50))(175(463)(858))))))(870(987(902)(793(245(598)(181(556)(741)))(794(566(606)(23))(144(974)(113)))))(616)))))(138(294)(817(682(23(686)(621(57(469(0(165)(458))(939))(744))(679(359)(520))))(951(20)(720(919(382(346(227)(563))(581(75)(737)))(526(492)(988(338)(481))))(173(801(534(421)(997))(908(513)(767)))(85(837(577)(754))(705(300)(246)))))))(622(93)(794)))))) +(266(36(732(651(967(999(294(444)(272(901(19)(737))(594(832(563)(42(679)(909)))(148(118(773)(289))(526)))))(414(771)(927(577)(635(596(874)(466(507)(186)))(346(474(418)(696))(971))))))(260(379)(173(984(25(366(498(711)(978))(364(704)(854)))(762(23(32)(186))(917(149)(719))))(72(512(995(492)(156))(14(495)(633)))(998)))(605))))(495(699(164(979(526(591(250(153)(373))(546))(846))(426(550(788)(463(224)(467)))(969(398(940)(166))(613))))(36(335)(595)))(587(490(34(161(73(888)(542))(470))(130(181(193)(24))(161(893)(422))))(752(518(71)(23(578)(863)))(533)))(122)))(296(278)(615(942(85)(441(16)(697(318(947)(602))(831(979)(926)))))(261(121)(291))))))(819(241(391(454)(879(5)(324(237(914(760)(805(885)(486)))(980(85(457)(481))(938)))(48(765(928)(240(394)(904)))(266(783(956)(362))(685(376)(530)))))))(683(640(334(300(772(941(271)(847))(415(314)(412)))(263))(843(180)(911)))(540))(883(879)(819(430(396(526)(335))(846(605)(538(620)(83))))(713)))))(33(614(141(577)(590(375(538)(974(784(190)(123))(995(274)(790))))(650(631(541(891)(107))(8(885)(327)))(539(508(933)(962))(217(890)(312))))))(375(520)(6)))(871(99(711(314)(153))(296(390(479(924(23)(284))(148(766)(244)))(1(366(838)(291))(854(911)(781))))(848(436(802(268)(956))(960))(330(145)(443(353)(67))))))(586)))))(74(417)(74(376(879)(784(271(992(843(220(184(444)(568))(36))(741))(557))(150(125(825)(281(40(20)(389))(913)))(46)))(834)))(405(321(937(729)(288))(445(388)(273(256(13(792(38)(649))(661(257)(329)))(174(899(701)(264))(47(350)(452))))(251))))(534)))))(224(431(869(877(17)(95(83)(695)))(718))(276(647(181(41(120(209(119(472(305)(496))(843))(483(171(657)(179))(448)))(390))(352(671(628(805)(454(927)(952)))(210))(262(800(565(702)(260))(664(510)(486)))(317(364)(34(303)(396))))))(622(778)(546)))(279(356(613(947(910(626(806)(708))(59(769)(630)))(984))(996(1(739(449)(386))(986(917)(915)))(204(680(921)(507))(868(468)(661)))))(576(965(935(727)(26(447)(89)))(321(976)(119)))(519(877(779(687)(322))(25(993)(430)))(356(903(109)(181))(189(220)(490))))))(78(404(644(271(682(417)(470))(405(327)(430)))(265))(444))(123))))(622(691(292(881(549(561)(496(198)(654)))(744))(541(7(580)(671(313)(426(679)(687))))(735(399(351(321)(671))(82))(487(690(811)(847))(377(638)(860))))))(817))(319))))(766(841)(499)))) +(626(134(15(117(906(278(110(566(407)(722))(589(365)(624)))(369(320(87)(483))(48(751)(540))))(950))(838(545(505(280(807)(853))(205(216)(880)))(676(457)(302(892)(608))))(49(195(357(477)(32))(999(846)(699)))(257))))(286(981(205(616(990)(21(578)(527)))(545(297(93)(389))(811(516)(875))))(257(880(741(736)(861))(236(64)(430)))(823(767(687)(308))(9(748)(879)))))(487)))(297(102(157(10)(105(433(254)(90(304)(472)))(687(456)(72(32)(180)))))(378(25(328(109(616)(959))(443))(918(732(581)(984))(66)))(517(655)(110))))(977(16(516(631(217(501)(201))(976))(985(866(571)(698))(176(351)(764))))(336))(93(759)(623)))))(718(274(97)(88(626)(107)))(165(127(78)(167(282(76(584)(294))(906(993(55)(526))(840)))(182(671)(753(535)(946(22)(895))))))(340(190(669(411(464(848)(239))(647(706)(187)))(772(41(64)(756))(849(239)(747))))(840))(224(614(36(233)(326(721)(879)))(344(62(284)(203))(614)))(504(247)(386(995)(110(167)(203))))))))) +(594(992(560(64(251(42(7)(36(23(104)(603))(433)))(369(715)(178(37(261)(975))(837))))(286(953(606(312(5)(284))(957(26)(138)))(808))(321)))(759(516(658)(464(898)(363)))(22(23(446(268)(784(31)(954)))(184(830(267)(797))(857(194)(426))))(670(474)(140(636(726)(787))(333))))))(924(299)(704(447)(316(215)(866(642(828(382)(151))(562(66)(570)))(418(719)(688(575)(748))))))))(348(533(241)(860))(307(908)(199(876(317)(465(426(630(378)(349))(528(21)(912)))(599(267(847)(809))(76(10)(98)))))(441(913(175(466(268)(953))(790))(157(862(974)(809))(925(888)(863))))(504(746)(500(982)(350)))))))) +(642(19(981(379)(316(85(903(548(115(551)(876))(664))(352(794(137)(88))(772(668)(719))))(63(691(694(741)(9))(149(573)(921)))(258)))(573)))(283(776)(59(392)(955(240(754(601(272)(194))(822(217)(944)))(998(646)(219)))(342)))))(18(532(86(215(289)(413(226(484(569)(835))(922))(589(728)(0))))(480))(263))(511(11)(32(406(519)(788(221(22(940)(577))(541))(772(247(721)(991))(785(600)(751)))))(526))))) +(178(616(609(309)(215(292)(626)))(359(579(620(220(904)(225(461(859(351(80)(187))(535(511)(72)))(568(118(733)(817))(334(284)(875))))(283(862(486(210)(510))(877(137)(991)))(652(382(576)(674))(0)))))(185(665(824)(819(939(803)(937(650)(400)))(510)))(179(790(394)(622(174(417)(421))(774(689)(888))))(434(38(138)(771(360)(641)))(893(798(539)(613))(298(866)(381)))))))(559(769(524(529)(290))(57(808(141)(365(780(563)(279))(543(504)(11))))(751(904(367)(20(380)(620)))(743(705)(347)))))(886(620(908(473)(936))(170(924(569)(243(447)(569)))(161)))(575))))(933)))(942(519(24(641(38)(687(672(43(811(859(595)(531))(716(930)(414)))(622(864(164)(754))(174(308)(767))))(533(626)(429)))(829(688(634(716(391)(950))(944))(798(63(912)(955))(558(155)(26))))(878(952)(973(409)(885))))))(691))(287(836(912)(492))(627(819)(41(738(808(777(696(203)(801))(18(126)(882)))(583(433(695)(57))(430(905)(841))))(882(301)(829(425(909)(710))(903(86)(454)))))(661)))))(378(575(329(634(341(401(108(409)(918(314)(866)))(40(436)(841)))(940(409)(832)))(741(817(481)(563(464(210)(163))(19(651)(653))))(212)))(484))(396(701(600(967(812(858)(762))(753))(13(834(386(632)(272))(523))(695(400(316)(316))(748(845)(442)))))(240(7(910(636(942)(862))(582(110)(696)))(523(951)(725(782)(751))))(12(971)(390(11(650)(996))(834)))))(665(363(322(246(666)(544(356)(317)))(233(122)(245(176)(101))))(820))(809(626(933(0(570)(762))(892(180)(72)))(294(28(863)(135))(305(552)(965))))(465)))))(777(810(172(436)(847(828(385(838(836)(379))(987(692)(580)))(149))(66)))(362(474(436(581)(549))(360(347(199)(956(898)(53)))(700(299)(830(926)(525)))))(441(713)(946))))(317(42(378)(226(789(806(451(198)(859))(570(233)(468)))(508))(596(114(95)(233))(865(454)(444(252)(674))))))(940)))))) +(921(84(278(331(133)(942))(173(139(406(314(510)(656))(963(307)(503)))(370))(815(143(4)(168(123)(613)))(62))))(203(857(641(309(868(773)(697))(475(183)(97)))(316(767(256)(959))(319(475)(27))))(192(49(733(155)(755))(142(568)(654)))(841)))(572)))(914(311(813)(148))(55(545(880(480(257)(567(94)(150)))(779))(502))(731(988(21(644(298)(105))(164))(179))(676))))) +(444(439(690(270(836(864(967)(763(222)(329)))(213))(797))(257(709(12(937(555)(544))(442(236)(649)))(264(878(843)(689))(869)))(911)))(622(313(737(337(254(264)(645))(561(40)(891)))(966(742)(892(967)(14))))(979))(772(646(650(451(368)(983))(479))(25))(907(837(368(326)(446))(715))(962)))))(639(589(860)(180(72)(680(231)(120(445(607)(613))(121(840)(90))))))(160(984(669(288(898)(191))(989(572)(889(232)(867))))(301(969)(623(541(815)(624))(252(316)(879)))))(560(702(38(97(980)(394))(958))(204(583(659)(402))(39(752)(412))))(416(756(252(49)(837))(954(640)(605)))(731)))))) +(193(527(973(446(167)(603(268)(451(599(412(24(368)(885))(568))(215(647(523(393(105)(404))(354(539)(911)))(378(752(46)(581))(827)))(942(504)(154(802)(635(464)(350))))))(170(830(269)(312(857(76)(734(378)(158)))(256)))(580)))))(267(14(264(906(760(207(897(421(335)(523))(633(687)(481)))(966))(485))(918(826(914(343(962)(503))(47))(550(228)(243(944)(993))))(50(407)(608(433)(903)))))(413(651(939)(48(385(128)(583))(218(188)(900))))(920(960(589(434(464)(281))(573(542)(672)))(807(62(280)(129))(770)))(361(645)(962(403)(562(193)(894)))))))(990))(529(305(560)(623(935(36)(711))(221(322(969)(161(405(534)(603))(869(966)(249))))(185))))(497(410(689)(642))(316(749)(534(149(306)(678(935(278)(890))(155(923)(724))))(869(210)(734(511(637)(147))(220(606)(871))))))))))(866(379(198(422)(589(197(156)(569))(770(689(474(600(312(382)(477))(534))(155(84(313)(343))(890(445)(313))))(808))(879))))(435))(613(579)(120(432(14(714)(491))(868))(861(844)(93))))))(535(657(983(508(158(630)(970))(455(100)(168(676(890)(353(986(401(658)(935))(213(672)(265)))(201(472(553)(536))(476(397)(793)))))(368))))(277(418)(354(897)(779(267(762(700)(305(758(183)(611))(152(567)(653))))(680))(304(395(622(26)(425(792)(148)))(307(50(378)(212))(582)))(508))))))(993))(210(681(23(536)(811(445(152(671(22(896(856)(73))(594(538)(80)))(948(36)(842(220)(411))))(251(135(395)(86(201)(137)))(107(665(935)(305))(445(174)(915)))))(611(145(406)(713(181(558)(258))(339(736)(794))))(783(54(427(674)(640))(404))(776))))(670(422)(935(422(331(433)(24(654)(549)))(394))(669(754(656)(801(512)(248)))(666(904)(299)))))))(733(48(986(260(205)(362(950(590(896)(901))(773(142)(382)))(517(755)(766(795)(340)))))(137(690)(367(955)(680))))(868))(869(18)(666(342(804(806(339)(292))(482(232(420)(276))(764(949)(455))))(28(43(374(142)(542))(202(158)(62)))(570(811(330)(105))(304))))(375(209(464(737(669)(457))(311))(505(514)(586)))(322(338)(535(843(157)(824))(801(342)(497)))))))))(485(346)(882(801)(250(638(316(4(849)(288(241)(757)))(169))(572(308(502(254)(558(744)(699)))(972))(55)))(738(154(89(736)(997))(983(884)(448(498(885)(454))(840(187)(49)))))(276(791)(107(112(550(24)(109))(889))(199(888)(679(917)(585)))))))))))) +(150(648(364(555(790(992(428(668(860)(521))(80(317)(177)))(143(871(753)(617))(760)))(707(782(739(605)(358))(213))(293)))(888))(357(79)(486(546(774(596(984)(73))(655(494)(0)))(232))(845(626(85)(673(526)(423)))(234)))))(677(471)(157(898(135(764)(913))(684(303)(711(687)(94(465)(755)))))(416(585)(215(156)(196(964(54)(268))(227(901)(815))))))))(667(295(574(535(609(969(843(901)(978))(85(551)(696)))(467(971(263)(585))(910)))(958(64(514(956)(91))(967))(343(820(388)(733))(672(811)(411)))))(594(827(705(658(740)(415))(220(438)(821)))(372))(380)))(995(950(887(468(794)(644(81)(393)))(743(918(64)(297))(615(737)(662))))(714(646(160(22)(477))(238(595)(934)))(655(419(995)(494))(275))))(19(934(287(350(995)(526))(815(287)(700)))(657))(217(258(548(492)(234))(0(609)(129)))(623(910(407)(90))(819))))))(448(210(802)(488))(763(93(194(276(440)(39(349)(137)))(683(561)(286(765)(324))))(968(196(849(282)(451))(803(247)(949)))(201(163(554)(469))(641))))(92(687(281)(193(780)(745(44)(376))))(894(337)(547(632(400)(108))(132(564)(903))))))))) +(920(126(443(750)(378(337)(148(226)(226(407(233(152)(557))(819))(773(248(714)(832(63(210)(589))(326)))(755(739)(391(658(225)(996))(54))))))))(225(662)(943)))(241(922(95)(547(359)(326(390)(577(291(138(16(235(155)(230))(536(81)(825)))(157))(285(827(345)(560(492)(887)))(788(286(922)(519))(433(990)(977)))))(181(540(810)(899(539(9)(152))(996)))(59))))))(346(949(18(872(207(714(633(564(809)(501))(505(529)(861)))(385(406(966)(776))(669)))(601(305)(422(119(459)(789))(441(219)(293)))))(637(795)(898(96(264(220)(681))(712))(793(198(96)(100))(204(566)(668))))))(969(880(853(858(101(44)(884))(840(265)(513)))(613(841)(950(672)(254))))(972(112)(793(16(834)(984))(625(837)(139)))))(140(215)(497(868)(530(898(775)(679))(738(73)(963)))))))(159))(98)))) +(231(604(477(11(561)(237(719(224(373(84(982(340)(583))(667(433(369)(560))(235(363)(315))))(60(213(794(663)(349))(908))(483)))(586(693)(607(430)(918(800)(84(326)(310))))))(348(328)(56(59(630(828(654)(590))(66(643)(368)))(261(583(671)(999))(155(637)(482))))(87))))(824(772(472(616(71(50(753)(496))(86))(545(446(543)(639))(979(82)(272))))(884(554)(672(48(634)(128))(356(245)(564)))))(792(769(461(199)(848(82)(961)))(446))(100(830(269(451)(304))(507(966)(62)))(665(323(168)(986))(65)))))(157))))(138))(738(619)(573(543)(643(991)(565(619(81(406(655(412(923)(626))(216))(806(585(702)(793))(152(541)(302))))(51(287)(122(861)(753(806)(682)))))(490(311(724(104(311)(240))(922))(933))(847(252)(240(294(418)(495))(659)))))(915))))))(416(822(299)(343))(665(987)(599(13(713(708(986(172(697(150(510)(255))(398(176)(315)))(12(187(483)(932))(943(831)(587))))(637(361(782(613)(399))(150(234)(753)))(162(133(155)(114))(943(579)(880)))))(619))(791))(504(554(202)(118(458(940(410(597)(464))(136(640)(463)))(686))(145(360)(666))))(599(705)(912(560)(896)))))(158(107(467(649(894(872)(402(190(732)(553))(924)))(243(686(865(679)(486))(237(101)(100)))(742(607(540)(258))(353))))(829(521(372(915)(933(613)(425)))(146))(27)))(482(543)(397)))(545(979(268(356)(695(9(554(795)(609))(879(246)(567)))(388)))(829(508(635(837)(97(994)(564)))(751(634(998)(880))(6(279)(317))))(710(20(173(27)(182))(520))(935(977)(680)))))(854(990(423(1(367)(152))(503(794)(143)))(605(602(170(788)(829))(899(244)(778)))(886)))(253(195(336)(123(90)(905(734)(111))))(298))))))))) +(430(653(443(105)(232(443)(42)))(720(69)(892(555(236(236(980)(424(469)(333)))(228(829)(355(657(816)(411))(562(54)(807)))))(385(785(31)(114))(731(103(730)(486(757)(770)))(503(497(323)(219))(689(763)(502))))))(372(788(972)(269(793(698)(859))(965)))(765(418(334(663(588)(399))(244))(373(614(897)(232))(488)))(476(723)(568(426(284)(818))(739))))))))(883(715(61)(760(128)(767)))(475(210(447(99(681)(66(942(563)(806))(545(541(975)(226))(549))))(317))(742))(384)))) +(352(389(685(369)(593(172(379(229(63(402(852(181)(832))(254(856)(917)))(105(86(732)(753))(896(39)(955))))(821(464)(58(475(779)(454))(567(152)(941)))))(24(640(873(124)(53))(133))(479(444(887(776)(733))(709(892)(564)))(1(872(756)(95))(834)))))(259(140)(920)))(130(834(312)(311(211(171(919(417)(990))(845))(353(877(718)(877))(483(413)(637))))(862(258(820)(61(820)(381)))(817(15)(156(613)(245))))))(506(762)(431(479(161(815(394)(90))(255))(191(300)(327(647)(268))))(461(397(548(465)(935))(513(736)(150)))(941(700(569)(788))(440))))))))(72(26(193(891(685(428(267(187(165)(175))(296))(440(659(408)(974))(826(365)(204))))(690(309(531(559)(333))(375(21)(529)))(357)))(837(106(729)(227(684)(357(257)(340))))(683(981(240(758)(494))(184))(550(250(438)(428))(161)))))(960(717(379)(94))(116(750(873(947)(195(130)(605)))(945))(194(806(633)(487(667)(607)))(790(897)(588(472)(873)))))))(959(975(691)(515(145(896)(917(688(384)(958))(109(503)(752))))(905(139)(826(880(748)(789))(202(76)(0))))))(541(705(249)(165))(703(580(959(950(607)(756))(909(208)(648)))(337(749(550)(167))(555)))(225)))))(36(607(941(821(926)(438))(951(523)(268(878(448(300)(917))(942))(678(364)(37(438)(650))))))(286(204(978(35(726)(229(615)(151)))(94(384(482)(625))(792(621)(535))))(370(377(925)(109))(887)))(726(935)(535(20)(736)))))(140(782(755(626)(319(834(461)(547(348)(824)))(531(671(692)(45))(504(663)(858)))))(913(933(72(774)(897(82)(106)))(636(179(749)(526))(24(869)(801))))(738)))(513)))))(735(739(276(620(147(78(148)(941(336(190(475)(408))(489(902)(249)))(293(749)(522))))(232(916(498(703)(983))(408(659(533)(54))(986)))(899(272(948(829)(595))(627))(892(153)(534(339)(421))))))(887))(484))(157(328(120(516)(517(108(321(930)(883(902)(752)))(273(474(612)(204))(419(175)(199))))(756(907(195(296)(582))(309(943)(787)))(946))))(780(339(328(371(289(330)(232))(602(508)(420)))(36(271(563)(440))(593(692)(809))))(909(831(64)(961(509)(409)))(77(672(822)(750))(111(952)(397)))))(974(850(481(872(264)(975))(435(255)(791)))(786(823(696)(180))(235(636)(437))))(486))))(391(270)(732(870(810(665(338(55)(387))(20))(755(131)(876(585)(385))))(528(157(153(816)(48))(717(158)(755)))(752(804(112)(198))(208(592)(593)))))(23(368(82)(61(107)(756(603)(49))))(418))))))(822(294)(495(158(214(764(626)(426(327(657(29)(219))(668(153)(885)))(619(985(693)(923))(976(216)(261)))))(778))(932))(415(50(224)(348(688(384(893(99)(249))(188))(513(739)(173(870)(919))))(352(83)(693(815)(896(354)(706))))))(137(283)(247))))))) +(386(254(927(22)(509(232(22(538)(664(938(400(493)(687))(410(971)(401)))(12(736(513)(770))(11))))(365(24(162)(127(784)(214(340)(447))))(118(163(637(140)(487))(626(437)(361)))(357(108(100)(391))(919(193)(400))))))(851)))(635(477(784(468(473(475)(436(594(668)(40))(445(615)(760))))(934(709(987(115)(59))(7(620)(234)))(76(425(122)(219))(661(945)(169)))))(275(854(286)(434(915(845)(111))(527(627)(491))))(639)))(32))(977(157(727(959)(923(912(702(636)(512))(537(811)(622)))(509(904(619)(831))(260))))(287(102(275(472(292)(395))(277(805)(264)))(979(869(595)(842))(315(827)(425))))(12(522)(377(942)(208(418)(232))))))(923(216(403)(849(533(768(467)(926))(847))(762(82)(316))))(349)))))(133(728(783)(70(924(975(995(983(285(623)(181))(288(284)(205)))(389(131(192)(115))(303)))(75(571(828(500)(307))(467(442)(846)))(183(103(44)(647))(419(204)(180)))))(287(656(394)(990(584(693)(759))(108)))(616(883(31(854)(323))(633(589)(887)))(706(223(586)(474))(404)))))(767(472(851)(351(270(970)(82(548)(128)))(347)))(242(588(58(961)(30))(275))(737(437)(101))))))(55(266(252)(149(36(9(262(861(8)(350))(910(337)(513)))(660(900(338)(740))(291(31)(269))))(744(704)(502(842(740)(110))(193(608)(975)))))(465)))(933)))) +(437(610(409(875)(468(741(136(542)(641(978(972)(426(664(906(465)(739))(550(261)(104)))(869(712(274)(550))(600))))(256(360(910(406)(724(30)(686)))(204(673(684)(467))(35(156)(397))))(807(417)(200)))))(866(793(351(891(403(332(681)(146))(708))(679(581(501)(2))(620(9)(389))))(841(854)(533(49(300)(226))(56))))(560))(416(879(387(824)(646))(417))(728(829)(291(887(349(965)(549))(628(226)(903)))(660(76)(108(595)(26))))))))(869(484(813(138(197(497(723(641)(739))(382(670)(363)))(806(968)(260(876)(867))))(71))(259(289)(578)))(423(90(683(816(171(545)(8))(264))(134(832(310)(539))(822)))(981(621(343(431)(78))(512))(341(145(862)(487))(683))))(670(429)(461(672(27(55)(393))(263(464)(654)))(986)))))(587(103(203(68(521(39(183)(954))(779))(331))(360))(895))(145)))))(883(420(581(639(522(73(225(103(925(622)(543))(398))(771(37(469)(20))(472(215)(532))))(891(187)(640(321(387)(69))(183(881)(396)))))(833))(572))(241(918(770)(411(912(516(14(205)(586))(919(541)(543)))(420(711(813)(314))(478(747)(773))))(322)))(601(193)(740))))(531))(550(809(942(38)(608(699)(827(114)(502(937(84(725)(31))(831(275)(531)))(836(614)(350(926)(28)))))))(488(911(868)(439(53)(323(151(970(331)(29))(13(82)(708)))(198))))(489(64(489(788(202(841)(924))(564))(600))(759(515(397(941)(945))(416(419)(784)))(11(253(173)(933))(51(604)(140)))))(657(248(277(40(243)(240))(48))(696))(445(493(177(646)(120))(764(59)(261)))(590(60(733)(385))(673)))))))(518(873)(289(353(294)(939))(643(515(461(702(164(910)(857))(777(131)(576)))(299))(345(457(349(876)(544))(607(873)(413)))(330(820(875)(248))(240(185)(874)))))(959(189(164(324(304)(413))(845(154)(698)))(462(513(776)(97))(566(152)(256))))(153))))))))(331(26(671(101(994(136)(145(680)(389(813(724(102(569)(85))(62(845)(127)))(315(286)(224)))(271(845(666(416)(789))(781))(18(936(464)(742))(242(76)(233)))))))(661(597(934(335(673(493)(501))(329))(761))(464(284(212)(993(190(643)(692))(393)))(853)))(869(608)(610))))(726(895(85(494)(961(865)(140(794(507)(683(487)(963)))(560))))(230))(542(570(140)(485))(952(301(100(559(621)(388(290)(283)))(471(213(967)(503))(304(341)(153))))(710(159(875(909)(213))(356(651)(726)))(226(474)(620(923)(209)))))(259(759)(96(411(399(68)(891))(340(150)(890)))(552(472)(429(27)(647)))))))))(594(885(42(513(634)(430(722(874(930(298)(493))(888(124)(509)))(134(483)(835(42)(227))))(158)))(900))(161(138(674(39(277)(919))(642(871(81(775)(601))(850))(994)))(909(552)(846(935)(655(628)(530(932)(787))))))(437(6(237)(892(363(352)(792(667)(17)))(754(243)(11(843)(764)))))(196))))(214(749(722(480(46(129(227(682)(361))(531(95)(701)))(684(880(779)(884))(826(137)(723))))(782(809(887(419)(727))(562(767)(316)))(177(660)(164(823)(889)))))(876(269(968(957(754)(220))(273(219)(139)))(158))(304(477(638(601)(727))(280))(686))))(896(232(267(836(139)(394))(580(653)(394)))(683))(662(223(857)(491))(270(380)(909(138)(85(553)(701)))))))(943(608(326(69)(437(114(562)(724(235)(946)))(786(629(624)(64))(918(148)(632)))))(867(600)(319(894)(118(66(508)(942))(753(43)(90))))))(142)))))(227(739(957(778(958(637(604)(521(323(681)(406(536)(283)))(911(789(798)(450))(195))))(359))(393(619(663(938)(113(69(270)(947))(665(657)(558))))(964(275(959(815)(724))(568))(225)))(845(247)(425(896)(367(917)(197(475)(139)))))))(817(215)(63(528(280(459)(873(158(593)(661))(862(12)(514))))(86(412)(183)))(680(125)(834(619(769)(382(899)(273)))(484(145(633)(989))(47)))))))(817(341(233(232(104)(563(938)(365(20(387)(134))(638(424)(450)))))(720(378)(593(807)(800(390)(91(915)(987))))))(673(536(696(180)(876(861)(963)))(509(103(409(61)(341))(639(931)(187)))(134(83(615)(933))(859))))(373(61(709(612(141)(118))(982))(902(913(747)(565))(755)))(193))))(524(132(754(78)(194(785(156)(481))(769(894(732)(25))(278(826)(480)))))(511(9(301(866)(987))(976))(433(781(433(216)(797))(925(670)(128)))(868(847)(299(468)(530))))))(712(468(482(15(38(818)(333))(629(857)(979)))(132(276)(685(563)(590))))(525))(918(44(261(180)(935(329)(892)))(263))(895))))))(64(366(892(954(932(660)(664))(825(98(163(330(23)(164))(160(126)(720)))(481(529(421)(959))(285)))(161)))(883(755(139(232(241(422)(536))(653(754)(643)))(980(417)(865)))(170(65(689(240)(962))(485))(784(964(339)(788))(15))))(444(766(894(729(234)(723))(55(544)(537)))(566(493(821)(677))(77(756)(32))))(584(682)(525(173)(16(913)(125)))))))(223(303(110)(481))(893)))(67))))) +(414(317(558(596(895)(972(651(698(229(857(482(170)(799))(929(77)(890)))(368(487)(324(812)(731))))(50))(312(98)(513(678(275)(171(430)(943)))(771(685(238)(843))(29(360)(759))))))(900(511(452)(536))(15(998(352(183(828)(415))(391(488)(705)))(586))(119(793(701)(81(408)(793)))(887(614(511)(456))(441(867)(910))))))))(458))(269(641)(181(158)(956))))(526(636(343(943)(105(786(324(650)(775(780(200(819)(818))(641(389)(246)))(561(221(148)(695))(358))))(740))(98(783)(89(495(705(630(869)(426))(734))(221(731(178)(968))(623(565)(233))))(569)))))(397(787(317(462(29(57(698)(752(669)(105)))(166(14(384)(612))(714(586)(717))))(227(452)(656(504(100)(222))(191))))(271))(975(930(686)(353(784(453(288)(214))(598))(725)))(779(294)(450(264(682(360)(36))(563(867)(578)))(998(836(99)(542))(499(52)(342)))))))(624(866(501(51(58)(916(908(341)(833))(165(139)(333))))(503(278)(646(787)(668(664)(783)))))(380(643(949(529(350)(390))(753))(94(992)(151)))(181(269(301)(755(683)(307)))(719(235(710)(677))(88(345)(168))))))(735(780(245(454(701(220)(299))(520(332)(732)))(114(530(11)(477))(754(208)(652))))(469))(226(742)(169))))))(490(202(971(770(338(538)(256(195)(757(740(282)(152))(226(796)(423)))))(462(437(368)(875(243)(8)))(275)))(594))(246(152)(684)))(148)))) +(226(770(234(350(271(866(603(770)(728))(62(659)(52)))(425(685(836)(716))(515)))(965(414)(914(192(628)(92))(279))))(937(993(268(13(81)(958))(169(878)(203)))(169(911(711)(4))(370(58)(352))))(517(494(283(988)(9))(785(680)(379)))(725(298(639)(416))(50(265)(167))))))(757(921(180(97)(690(717(984)(312))(877(248)(964))))(213))(37(671(376(391(845)(557))(468(201)(491)))(392(592(31)(565))(544(171)(569))))(228(246)(799(106)(149(885)(290)))))))(181(849(630)(959))(361(824)(307)))) +(174(201(356(540)(797(158(446(853)(734(573)(265)))(326))(288(205)(579(261(162)(623))(382)))))(814(343)(862(841)(681))))(554(169(416)(3(417(144(260(317)(916))(70(791)(109)))(272(128(333)(414))(755(634)(697))))(556(75(438(809)(857))(164(550)(576)))(298))))(330(753(137)(300(294(343)(896(959)(706)))(818(32(386)(80))(202(95)(785)))))(497(407(822(318(344)(197))(319(777)(113)))(836))(989(703(691)(164(165)(498)))(175)))))) +(396(724(264(500)(455))(328(15(925)(274(524(427)(509(164)(400)))(380(845(545)(369(845(278(184(37)(850))(769(552)(647)))(729))(96(191)(573(803(970)(526))(21(295)(844))))))(484(239(28(979(557(805)(153))(951))(646(358(50)(890))(374(522)(289))))(478))(755)))))(376(615(589)(799))(811(93(51(815(83(836(958)(376))(455(197(975)(653))(367(654)(945))))(968(399(347(94)(187))(567(12)(809)))(515)))(72))(281(839)(449)))(857(583(135(93(183)(589(625)(617)))(538(847(940(191)(619))(726(240)(167)))(67(667(650)(944))(839(750)(238)))))(9))(463(912)(104)))))))(427(490(126)(405))(27(579(454(260)(550(395(878)(278(811)(311(97(14)(257(342)(399)))(478(213(763)(510))(927)))))(749)))(820))(744(864)(159(932(266(123(743(753)(491(481(725)(472))(830(564)(241))))(133(133(116)(453))(312(627(299)(190))(114(813)(347)))))(662(773(853)(440(688(297)(268))(511(137)(795))))(779(373(816(705)(702))(924))(713(738(436)(303))(28)))))(57(782(367(726(528(347)(357))(281(746)(892)))(87))(548(673(18(544)(41))(766(489)(496)))(935)))(792(417(34)(77(228(640)(148))(634(811)(990))))(184))))(83(682)(46(520)(914)))))))) +(812(323(627(316(479(971(438(688)(333))(422))(646))(914))(102(662(772(43)(681(862(35)(729))(830(24)(926))))(509(38)(844(833(627)(80))(655(803)(389)))))(327)))(178(678(626)(182(176)(294(484(346)(161(814)(308)))(824))))(814(310)(226(800(76)(785))(62(649)(946))))))(210(144(274(179(932)(437(754(242(78)(154))(250))(838)))(306))(309(289(895(916(850(962)(971))(452))(512(132(64)(845))(780)))(374(85(761(428)(223))(804(425)(339)))(523(912(690)(733))(441(112)(833)))))(463(408(318(807(334)(162))(911(256)(841)))(529(607)(334(116)(13))))(239))))(203(161(534)(602))(353)))) +(529(760(402(704(675(10(513(363(340(934(195(916)(190))(369(989)(160)))(65(725(236)(49))(404(454)(220))))(933))(205(727(481(580)(191(285)(120)))(47(607(151)(619))(661(821)(740))))(551(463(635)(380(267)(667)))(676(395(496)(510))(91(495)(824))))))(803(445)(675(773(217)(173(331(823)(234))(20(311)(289))))(951))))(682(901)(504(415(677)(679(985)(38)))(380(331(294)(371))(23)))))(752(341(66)(6(413(854(585(691(853)(295))(343(494)(831)))(997(359(156)(114))(137)))(923(116)(733)))(389(723(815)(956(498(933)(659))(406(167)(199))))(771(180(96(673)(701))(667))(857)))))(615(609(993(822(594)(450(606(208)(422))(564(866)(486))))(447(193(196(582)(765))(840(842)(614)))(615)))(899(595)(67)))(661(285(98(718)(726(414)(509(630)(184))))(164(619)(710)))(390)))))(342(468(60(437)(15(233(843(863(980)(324))(982(649(947)(683))(593(601)(330))))(269))(838(759(968(750(841)(653))(435(727)(913)))(241(94)(670)))(555))))(936(718(573(925(734)(537))(542(228(424(387)(315))(426(795)(781)))(67)))(680))(933(107(472(355(218(193)(270))(623(394)(818)))(181))(701(870(542(111)(554))(419))(310(933(726)(117))(255))))(123(813(749(352(404)(990))(766(113)(7)))(5))(825)))))(545)))(616(338(541(34(916(172(382)(921(114)(773)))(704(448)(980(927)(108(737(367)(28))(608)))))(865(591)(499(949(592(431)(765))(20(309(726)(502))(712)))(148(173(257(159)(117))(135))(900)))))(874(628(960)(676(531(334(438(469)(846))(230(725)(585)))(735(53)(628)))(684(850(63)(950(673)(274)))(544(12)(988)))))(33)))(122))(343)))(52(226(251)(375(507(538)(940))(608(315(400)(300(460)(782(802(148(779(358)(959))(829(333)(525)))(429(921(686)(402))(146)))(678))))(659))))(99(669(111(66(742)(777(944(343(411(683(839)(322))(118))(684))(838(311(352(50)(362))(634(573)(323)))(775(4(654)(233))(162(449)(909)))))(528(130(110(469)(116(923)(663)))(524(958(887)(814))(654(69)(59))))(903(310(138(290)(752))(100(508)(513)))(950(678(19)(512))(898(908)(968)))))))(56(730(756(786(46)(827))(775(28)(772(836)(607(883)(120)))))(438(821)(612(258(247(539)(771))(318(581)(427)))(159(483(159)(66))(304(791)(807))))))(397(211(496)(444(342(237(816)(723))(995))(508(822)(549(275)(604)))))(252(515(718)(525))(898(630)(992(378)(701(451)(738))))))))(197(92(243(214(743)(72(32)(309(205(94)(778))(774(508)(252)))))(50(197(789)(261(918(894)(916))(761(138)(820))))(107)))(477))(463(499(213(452(805(158)(885(120)(892)))(990(860(336)(760))(352(818)(734))))(546(729)(813(621(707)(441))(661(36)(827)))))(658))(705(787)(623(51(386(360(800)(253))(502))(702(912(386)(632))(170(648)(869))))(195(426)(804(434)(446))))))))(684)))) +(212(454(677(225(655(101(997(203)(529))(976(769)(58)))(800(500(517)(747))(665)))(874))(581(189)(215(89(838(367)(820))(614(107)(320)))(475(399(110)(997))(223)))))(245(855)(869(885(813)(388(243(338)(188))(221(898)(482))))(7))))(153(228(330(448(181(26(287)(246))(855(193)(404)))(472))(146))(41(696(432)(798))(514(235(779)(884(71)(503)))(941(509(575)(216))(521(827)(234))))))(649(937)(778)))) +(629(269(370(416)(444))(951(570)(665(782(695(691(931)(813))(315))(60(616)(12(181(945(261)(669))(525(487)(907)))(983(75)(503(592)(360))))))(501))))(310(186(101(736(472(857(451)(842(473(429)(420))(255(348)(309))))(783(356(881(598)(22))(884(504)(125)))(64(94)(525))))(905))(314(286)(696)))(3(454(85(2(292(126(568)(172))(833))(515(881(360)(773))(694(276)(91))))(387(896(266(610)(815))(726))(507)))(352(865)(244)))(106(146(829)(419(130)(393(249)(278(736)(294)))))(716))))(206(53(604(693(635(646(690(759)(493))(27))(980))(376(770(790)(277))(936(829(971)(234))(946(82)(374)))))(351))(678(204)(423(215)(963(11(13(602)(734))(305(196)(671)))(442(317(340)(705))(173))))))(393(32(174(436)(334))(536(147)(324)))(991))))) +(366(957(843(140(214(755)(408(487)(162(452(225(281(863)(484(68)(68)))(309))(428(59(752(29)(49))(786(515)(321)))(78)))(882(125(279)(983(141)(503(129)(777))))(688)))))(939))(148(869(249(302(563)(28(597(505)(616(597)(685)))(215)))(382(553(790(416(950)(433(507)(276)))(28(798(905)(20))(789(934)(213))))(889(888(623(13)(47))(838(861)(296)))(604(544(382)(580))(18(371)(605)))))(572(380(602(37(955)(885))(720))(452(232(275)(1))(999(383)(338))))(100(724(617(900)(719))(658(560)(790)))(632(750)(98))))))(886(691(96)(504(112(453(611(124)(792))(620(850)(228)))(313(128(230)(326))(195)))(50(853)(41(459(856)(317))(4)))))(380)))(955(790(670(706(37(725(635)(336(690)(909)))(215))(983(977(258)(865(438)(688)))(414(206(921)(850))(77(384)(913)))))(973(700(202(395(908)(308))(266(836)(326)))(909(11)(873(986)(262))))(797(421(968(794)(755))(235(13)(53)))(336(195(938)(140))(637(257)(609))))))(979))(379(144)(445(825)(128(710(990(606(896)(992))(238(845)(804)))(942(547(901)(911))(913(865)(26))))(25(728)(603))))))))(33(880)(5(597(277)(347))(240(374(119(609(69(496)(354(5(689)(927))(553(2)(902))))(743(711)(929(792)(897(560)(348)))))(570(48(434(107(519)(310))(182))(704(621(759)(64))(841)))(204(448)(525))))(618(645)(877)))(468(852)(527))))))(629(75(638(587(475(847)(337(861)(157(769)(31(28)(900)))))(161(780(299(700(189(566)(779(517)(536)))(517))(893(784(2(25)(277))(548))(519(388)(318(441)(185)))))(813(197)(503(577(597(806)(341))(240))(354))))(540(857)(444))))(863))(837(719(189)(796(778(401(79(663(492(947)(970))(575(586)(577)))(52(592(352)(46))(160)))(416(274(898(448)(846))(983(73)(381)))(90(874)(924(254)(244)))))(402(925)(295(149)(537(195(632)(820))(25(151)(734))))))(614(299(449(431)(534(787(548)(262))(821(622)(657))))(711))(478(564(988)(44(752(65)(969))(245(769)(390))))(705(613(596)(941))(326))))))(128(647(353(303(587)(212(556(674)(276))(657(67(405)(496))(886))))(917(544)(723(531(794(97)(337))(587))(879(532(858)(257))(381(567)(612))))))(6(386(599(323(772)(287(449)(323)))(642))(73(463(222(813)(637))(14(880)(303)))(19(458(231)(527))(612(638)(799)))))(389)))(182(291(132(352(700(170)(496))(158(931)(489(788)(104))))(312(7)(843)))(279))(654(397(729(6)(188(459(187)(646))(851(963)(328))))(488(614(117)(668))(243(259(999)(468))(779(198)(752)))))(670(553(445(392(191)(557))(207(119)(96)))(181))(190(767(898(1)(588))(504))(462(661(546)(40))(593(49)(876))))))))))(92(629(253(115)(327(441(737(778(393(865(387)(977))(663(468)(881)))(123(170(273)(117))(55(89)(2))))(469(912(869(676)(960))(290(21)(139)))(817)))(257(5)(484(978)(707(896(74)(967))(902)))))(136(603(381(691(230(108)(293))(497(2)(302)))(186(198(184)(901))(788)))(344(429(798)(80(626)(45)))(254)))(206(33)(18(547(293)(733(555)(834)))(70(509)(352)))))))(80))(283(851)(366(412(26(118(67(946(883)(510(303)(716)))(474))(746))(156(610(67(749(524)(376))(801(246)(982)))(919(626)(630(829)(396))))(858(612(157(285)(201))(868))(579))))(955(467)(974(296(545)(587))(451(594(99(483)(313))(359(323)(228)))(375(150(69)(958))(388(660)(995)))))))(372(785)(496(684(207(791)(196))(93(156(803)(649(706)(323)))(573(902(558)(742))(824(829)(775)))))(235(659(57(222(519)(237))(952(682)(329)))(487(929)(805)))(95(115(18)(518))(985(403)(793))))))))))) +(365(425(1(856)(393))(741(830)(219(688)(615(33(619)(964(346(686(668)(209))(223))(256(928(94(799(619)(18))(48))(114))(110(393(722)(557))(628(609(476)(582))(158))))))(308(755(419)(160(389(653(673(126)(340))(264))(561(185)(861(231)(726))))(674(771(648(642)(483))(569))(628(502(822)(625))(916(168)(596))))))(733))))))(364(49(346(165(938(721)(951(618)(741(323(244(285(532)(936))(647(422)(855)))(665(198(28)(352))(952(115)(922))))(721))))(608(779)(856(193(681)(794))(629(635)(506(342)(953(179(399)(189))(617)))))))(94))(739))(884(604)(581(49(189)(653(576(734(415)(682))(291(52(494(798(401)(928))(613(181)(151)))(956(807(119)(992))(151(458)(580))))(293(877(986(725)(342))(47))(701(300(809)(477))(63)))))(250(300(671(73(431(866)(323))(563(480)(79)))(384(291(881)(609))(24(736)(946))))(60(52(560)(222))(921(834(570)(807))(579(944)(394)))))(934))))(775(972(919(23(95(852(874)(305(457)(808)))(589))(324(122)(991(990)(324))))(618(814)(551(442(364(868)(963))(531(36)(475)))(551(176(276)(496))(802(749)(115))))))(939(531)(686(779(466(733(708)(15))(167(26)(582)))(742))(227(698(795)(224(73)(198)))(484(364(36)(286))(510(466)(548)))))))(251)))))) +(963(87(648(755(191)(334(790(853)(584(434)(84(13(549(699)(53))(429))(871))))(71)))(51(823)(977(2(252(316(345(142)(594(198)(697)))(934(992(916)(817))(600(337)(603))))(867))(344))(262(914(241(32(52(95)(174))(381(384)(158)))(110))(733(200(273)(211))(844(536(625)(167))(293(61)(283)))))(808(189(617(742(924)(812))(508(217)(394)))(100))(908(330)(754(499)(585(354)(129)))))))))(461(950)(520)))(261(831(276(290(641)(101(343(566(278)(367(618(47)(595))(358(328)(537))))(149(684)(612(805)(769(816)(578)))))(280(258(825(926(879)(606))(193))(564))(71(630(293(732)(946))(712(473)(625)))(374(67(218)(854))(895(862)(220)))))))(957))(861))(661(64(880(162(868)(654(251(465)(650(708(567)(669))(480(629)(825))))(734)))(743(413)(776(282(374(680(629)(384))(651(574)(174)))(357(835)(514(434)(570))))(904(994(219(989)(679))(977(539)(365)))(804(255(405)(986))(76(170)(185)))))))(457(230(341)(892(678(70(654(201)(978))(422))(502(312(773)(106))(857(770)(750))))(824(52(654(397)(186))(862(907)(82)))(960(239)(298(551)(854))))))(116)))(352(929(110(132(637)(12))(114))(565(540(413)(314))(39(287(826(757)(642))(398(916(351)(451))(925(909)(727))))(521(751(437(18)(293))(611))(23(665(487)(873))(609))))))(603))))) +(991(212(432(0(746)(924))(617(505)(327(629)(597(321)(836)))))(389(984(521)(38))(514)))(310(341(782)(246(222(564(951(759(323(682)(259))(532(407(680)(494))(754)))(83(634(232(70)(72))(515(588)(644)))(968(267(985)(86))(239(335)(637)))))(437))(751(53(581)(353(191(675(402)(120))(189))(787(559(285)(474))(765))))(126(168)(235(777)(264(685)(968))))))(39)))(804(817(424(512(887)(134(603(807(360(348)(254))(468(10)(352)))(829))(445(471(447(45)(637))(669))(720(938(560)(221))(510(609)(510))))))(204))(706(528(498)(769(667(915)(36(332(635)(584))(626(599)(888))))(690(287)(173(412(571)(630))(273(434)(874))))))(775)))(354(269(109(379(258(542(754(774)(853))(537))(502))(713(582)(605(662(755)(36))(575(172)(227)))))(292))(147))(130))))) +(507(30(140(749(204)(234(249(554(539(836)(9(663)(437)))(722))(768(160(624(127)(783))(865(41)(793)))(310(742)(694))))(153(715(887(272)(525(627)(399)))(612(627(65)(560))(680)))(237))))(378(222(49(196(434)(118(675(755)(719))(498)))(401(105(363(19)(548))(569(352)(715)))(657)))(378(957(613(395)(518(133)(545)))(967(570)(607(961)(245))))(530(625)(75(76)(901)))))(174)))(762(847(530(373)(55(480(32(554)(387))(161))(563)))(501(3)(109(769(251)(323))(833))))(152(928(233(535(161(838(913)(61))(816))(673(375)(131(451)(543))))(121))(10))(827))))(989(850(965(986)(894))(674))(157(71(400(659(794(17(703(544)(549))(732(707)(499)))(529(939(253)(588))(986(920)(589))))(146(317)(939)))(364(881)(801)))(919(589)(344(827(329(206(812)(910))(238(627)(182)))(488))(113(867(813(457)(886))(74))(352(447)(246(590)(707)))))))(148)))) +(494(696(54(206(236(544(467)(226))(932(327(332(425)(940))(751))(463(571)(768(860(652)(778))(423(87)(479))))))(916(850)(271)))(404(929(457(922)(187(394(176)(46(899)(232)))(208(753(644)(718))(746))))(841))(789(659(902(481(964)(767(273)(745)))(988(808)(188(529)(545))))(656))(545(953)(512(638(273)(200(915)(751)))(960(255(752)(880))(794(593)(953))))))))(250(534(470(889(676)(268(654(520(730)(156))(506))(721(991(574)(253))(495(93)(766)))))(132(282(138(973(731)(1))(795(312)(496)))(292(371(909)(322))(423)))(54(789)(388))))(730(343(332(395)(694(586(468)(344))(282(335)(64))))(427(515(500)(221(958)(465)))(597)))(427)))(554(581(59)(569(50)(88)))(359))))(839(328(939(877(699(624(810(551(635)(239))(914(691)(577)))(933))(710(225(187)(353))(23(352(375)(186))(731(1)(277)))))(735(917(439(619(979)(311))(820(210)(117)))(484))(425)))(239(593(210(986(716)(381(860)(732)))(741(3(661)(971))(968)))(526(264(532(364)(340))(740))(324)))(202(272(125(388(418)(162))(333))(130(12(428)(185))(284)))(0(219(632)(812))(632)))))(808))(662(13)(410(443)(375(635(816(757(769(636)(739))(629(988)(248)))(476))(719(224)(728(329)(386(706)(693)))))(181(366)(595))))))) +(420(450(527(243(482)(130(199)(34(648(718(993)(215(748)(563)))(290))(303(698(917(854)(324))(966(37)(947)))(471)))))(552))(487(216(910(604(465)(982(813(831)(788(115)(31)))(572(470(43)(315))(330(991)(688)))))(635(974)(389)))(910))(439(640(836(95(130(410(757)(649))(229(659)(705)))(675(477(505)(424))(752(130)(509))))(26))(691))(718(7(58(953)(840(530(594)(301))(243(955)(791))))(77))(55)))))(682(380(558(469(455(449(205)(757))(164))(439(358(104(781(962)(717))(938(624)(758)))(102))(778(841(607)(972(880)(945)))(156(948)(841(541)(423))))))(631))(241(346)(958(741(917)(949(97)(813(627(72)(872))(297(287)(312)))))(17(87(780)(636(515)(139(820)(616))))(890(921(246)(343))(111(599)(850)))))))(983(322(398(608)(801(479(700(448)(488(958)(783)))(30(334)(895)))(104(2)(620(333(722)(524))(470(73)(312))))))(402(860(82)(62(805)(158(286)(23(217)(376)))))(1(566)(976(254(112(77)(834))(75(626)(307)))(763(226(484)(362))(328(566)(758)))))))(406)))) +(443(975(318(463(260)(832))(968(854)(292(691(177(32)(79))(959(580)(51(293)(155))))(890))))(723(209(659(95(266)(684(903)(635(684)(170))))(403))(697(626(731(944(550)(454))(466(83)(755)))(272(455(879)(596))(752)))(377(492(973(823)(302))(173))(699(748)(776(48)(215))))))(443(812)(485(34)(120(456(633(357)(818))(777(500)(912)))(811))))))(144(595(370(489(847(151(607(959)(938))(364))(783))(680(228(339(983)(734))(554))(815(445)(798(669)(544)))))(146(830)(601)))(746))(553(279(72(742)(79(225(58)(146(672)(450)))(212(127(511)(916))(34(561)(148)))))(172(306(258)(8(532(374)(524))(951(381)(269))))(284(408(267)(821(129)(692)))(177(848(10)(944))(885(855)(510))))))(783(807)(271))))) +(455(339(734(839)(929(695(655(650(560)(829))(600(92)(660)))(997(442(697)(627))(664(471)(557))))(474(823(208(344)(744))(471(209)(566)))(947(999)(581(614)(767))))))(839(536(747)(881))(460(524)(252(829)(278)))))(228(853(925)(288(203(216(960(443)(160))(55))(993(385(170)(251))(419(390)(434))))(964)))(802(512)(956)))) +(73(767(422(408(82(896)(362(23)(82(839(488(228(339)(739))(891(977)(483)))(487(531(817)(36))(584(20)(773))))(437(89(372)(765(166)(72)))(376(824(195)(867))(397(225)(785)))))))(651(626(375(30(27(563)(960))(194))(92(937)(42(491(921)(302))(775(998)(930)))))(565(419)(441(992)(751(292)(517(436)(769))))))(807)))(1))(900(806)(189(650(16)(863(22)(339(845(46)(67(52)(389(641)(411))))(153(362(461(524)(310))(207(465)(275)))(311(17)(974(857)(716)))))))(683(618(381)(749(598(979(604(556)(698))(352(394)(913)))(36))(195)))(140)))))(478(532(738(352)(522(209)(627(837(624)(81(869(508(149)(313))(449(953)(683)))(40(833)(575(89)(307)))))(798(406(784(278)(671(275)(458)))(989))(644)))))(58(252(86(930(739(357)(846(626)(334)))(672(550)(754(796(868)(41))(316(331)(324)))))(164(148(310(169)(913))(804(824(859)(920))(243(67)(735))))(876(381(344(354)(15))(571(877)(29)))(419(282)(135(490)(581))))))(530(251(410(175(892(989)(834))(593(558)(235)))(811))(52(226)(511(646(443)(706))(704(217)(968)))))(984(443)(923(792(129(60)(420))(194(705)(291)))(409)))))(803(209(21(604(494(53(232)(704))(924(338)(746)))(891(87(133)(384))(669(195)(358))))(550(853(291(482)(815))(755(740)(7)))(490(104(201)(466))(303))))(602))(779(557)(86(677(524(636(579)(84))(96(173)(520)))(109))(168))))))(591(556(598(27)(457))(851))(542)))) +(65(232(525(329(183(74)(953(331(995(8)(128))(257(699(151)(934))(705)))(878(622(758)(327(246)(101)))(680))))(9(12(776)(174))(77(541(432(604(363)(98))(615))(586(266)(390(30)(372))))(785))))(199(20(593(884(271)(589))(609(519)(516(300(328)(211))(307(263)(359)))))(203(947(838)(42))(828(517(407)(485(886)(849)))(666(464(353)(684))(644(995)(720))))))(845)))(386(85(512(245(724(405(348(552)(382))(913))(669))(571))(834(781(185)(836))(843(909(36(65)(610))(142(505)(838)))(214(697(573)(881))(720)))))(507(553(159)(258))(847(122)(840(115(868(206)(662))(17(771)(982)))(572(290(24)(746))(666(783)(986)))))))(405)))(45(87(707(530(711(613(585)(947(823(635)(742))(315(82)(988))))(291(495)(433(749(570)(474))(592(823)(432)))))(712(629)(419(338(114(965)(419))(107(19)(335)))(674(720(910)(769))(25(210)(569))))))(711(78)(498(715)(674))))(721(187)(942(965(621)(433(57)(772)))(345))))(566(848(192(160(483)(390))(870(596(42(120)(366(485)(275)))(235(963(446)(869))(62(37)(354))))(603(457(678)(745(947)(28)))(614(495)(681(766)(588))))))(138))(617)))) +(475(409(68(109(84)(634(702(945(49)(477))(147))(287)))(356))(994(313(788)(151))(32(594(420(384(938)(491))(831(52)(196)))(338(402)(281)))(290(286(294(364)(927))(603(797)(200)))(348)))))(675(497(397(726(127)(444(891(993)(623))(327)))(586(8(118(300)(946))(716))(952)))(567))(326(805(989(391)(796(319)(436)))(747(802(189(416)(594))(772(951)(952)))(282(14)(97(830)(415)))))(977)))) +(131(145(274(990)(612))(201(139(655)(119(730(229)(803(80(312(811(374(959)(863))(180(867)(703)))(46(385)(79(181)(218))))(188(223)(956(487)(435))))(327)))(661)))(316(883(534)(315(803(248(251(84(788)(945(978)(483)))(309(321(656)(3))(49(464)(40))))(438(810(9(688)(994))(340(718)(852)))(28(175(949)(455))(559(609)(367)))))(225(828)(294)))(798(424(69(453(84(526)(852))(577))(811))(620))(789(560)(511(81)(324))))))(500(832(378(537(3)(156(942(768(149)(699))(286(917)(914)))(763)))(823(716(381(322(812)(237))(586(618)(644)))(222(479(446)(293))(306)))(850(379(563(383)(519))(371(752)(934)))(76))))(13(480(91(107(431(576)(52))(515(99)(812)))(237(68)(671(891)(809))))(69(255)(504)))(501(764(790)(687(246)(2(66)(306))))(682(560(31)(174(860)(794)))(922(533(593)(294))(870))))))(98(239)(857(491(684)(788(254(723(704)(180))(212))(167)))(54(404)(404(599(127(980)(956))(56))(801(569(267)(733))(841(871)(272)))))))))))(265(823(681)(373(261(54(471)(635(463(506(941)(860(184)(431)))(851))(435(741(26(790(871)(733))(944(526)(498)))(938))(1(211(92(981)(690))(534(499)(975)))(279(987)(129(195)(434)))))))(139))(587)))(608(72)(45(716(229(30(347)(773(265)(539(602)(912))))(455(907(859)(775(56(270(805)(884))(523(45)(342)))(219(215)(194))))(186(821(828)(978(555(971)(116))(106(575)(597))))(295))))(107(792)(237(451(219(517(252(114)(963))(374))(535(85(726)(941))(366)))(758(61(25(923)(539))(28))(76)))(843(382(584(813(123)(105))(712(953)(328)))(798(108(186)(828))(917)))(255)))))(418))))) +(642(524(376(111(612)(962(336(157(56(738)(252(164(990)(656(271)(12)))(262(406(250)(455))(478(42)(537)))))(822(408(51(318)(392(48)(402)))(995))(270(524(975(727)(246))(437))(86(369(747)(755))(909(697)(685))))))(982(492(787(914(671(617)(327))(512(365)(814)))(412))(534))(467)))(32(187)(103(343(605(727(330)(559(266)(489)))(889(901(248)(945))(212(393)(474))))(256))(361)))))(470(629)(738(786(518)(724(233(779(711(854(444)(615))(768))(765(607)(7)))(253))(220(979(350(21)(501(949)(739)))(662))(949(620(700(767)(294))(972(28)(892)))(784)))))(376(729(695)(476(683)(540(410)(646))))(142(398(241)(877(77)(539)))(133(930)(821(222(84)(554(120)(433)))(573))))))))(352(538(789(466(254(834)(778(295(698(428(103)(234))(736(107)(546)))(270))(47(262)(599(6(791)(409))(879(191)(795))))))(770))(830(172(671(405)(416(897(174(122)(680))(23(971)(498)))(702(422(17)(297))(44(368)(130)))))(918(540(154(576(86)(505))(397(116)(311)))(727(393(17)(25))(769(187)(675))))(311(222(381)(850(308)(584)))(396(557(609)(786))(471)))))(325)))(908(156)(506(640(283(270)(321(462(958(85)(914))(323))(978(502(59)(218))(971))))(614(626)(850(466(794(228)(720))(636(81)(636)))(657(628)(115)))))(173))))(851(127(444(242)(631(854)(803)))(458(956(354(217(377(363(688)(183))(745(722)(828)))(408))(831))(584(410(567(737(557)(575))(110(93)(779)))(143(620(853)(381))(505(313)(870))))(266)))(821)))(751(183(206(990(352(550)(926(883)(15(750)(654))))(336(869)(572)))(121(146(714(385(380)(320))(253))(578(671)(350(481)(50))))(849(555)(973))))(752))(478(587(951(117(521(175(525)(117))(929(64)(905)))(206(49)(611(312)(487))))(560(248(222)(543(880)(379)))(120(758(168)(492))(903(145)(161)))))(539))(789))))))(14(99(473)(822(49(960(325(628(511(515(738)(88))(49(765(549)(395))(932)))(227(565)(278(897(538)(991))(482(601)(112)))))(115(916(231(281(427)(360))(238(138)(172)))(797(83(422)(646))(680(365)(50))))(294)))(648))(64(7(52(684)(369(356(991(59)(748))(589))(924)))(24(401(293(470(417)(580))(435(640)(516)))(243(412)(222)))(342(849(557(962)(552))(89(707)(667)))(528(942(953)(49))(568)))))(143)))(222(564(438)(0))(352(947(593(508(73(712)(947))(422(445)(361(297)(141))))(180))(770(83(263(770(175)(137))(302))(849(102(115)(415))(688(553)(476))))(666(931(218)(60(411)(711)))(784))))(776)))))(694(519(226(181(19)(394(803(576(6)(284(915(177)(127))(326(132)(146))))(166(972)(996)))(437(920(652)(530))(397(38)(473)))))(324(683(726)(524(605)(1(866(967(955)(6))(21(278)(638)))(551(348(604)(628))(926(857)(758))))))(113)))(113(36(367(371)(810(859(312(908(95)(410))(892(248)(630)))(660(476(286)(727))(463)))(860(979(93)(358(10)(186)))(746(608(152)(391))(382(742)(606))))))(618))(85)))(387(861(385(498(101(91(949)(820))(728))(568(502(99)(723(322(530)(223))(698(610)(944))))(286(11(955(795)(607))(68(227)(138)))(520(786(945)(652))(944(174)(290))))))(984(954)(712)))(753))(826(632)(990)))))) +(856(996(876(525)(973(564(607)(316(599)(529)))(622)))(786(486(674(358(719(429)(742))(261))(161(73(586)(841))(772(653)(408))))(586(786(695)(126(280)(629)))(388(14(665)(143))(85(945)(797)))))(592)))(910(208(767(404(290)(386(813(29)(174))(849(265)(424))))(864))(432(381(689(684(299)(846))(205(911)(111)))(702(524(484)(236))(142(156)(705))))(985(63(450(144)(31))(841))(205(706)(597(685)(768))))))(862(332(227(563)(531(446)(844(191)(406))))(509))(992(560(921)(644(418)(519(178)(64))))(84))))) +(176(101(948(912)(486))(928(57(356)(199(755)(211(569(605(596(954)(618(319)(393)))(146))(890(855(688(129)(106))(982))(46)))(828(549(717(775)(460(58)(452)))(370))(708(506(313(442)(200))(521(62)(352)))(149))))))(64(150(4)(96))(944(30(619(77(587(701)(11(478)(837)))(984(547(148)(696))(773(262)(270))))(668))(802(166)(789(148(721(917)(265))(20(330)(271)))(155(608)(29(109)(950))))))(848(530(11(620(288(440)(906))(18(692)(294)))(296(335(256)(353))(499)))(872))(949))))))(819(68(181(382(370(295(681)(117(662(946(994)(184))(961(875)(933)))(221(242(919)(615))(197(155)(622)))))(587(718(490(708(555)(878))(635(316)(218)))(884))(231(280(186(96)(483))(828))(688(155(87)(185))(289(928)(929))))))(422))(968(809(918(289(663)(326))(453(20(518)(744))(96(267(972)(243))(239))))(738))(672(337(59(844(404)(403(572)(174)))(102))(675(832(699)(755(660)(825)))(345)))(401(226)(17)))))(25(120(102(301(260(830)(305(979(689)(549))(586(897)(364))))(579(177)(476(946(956)(947))(626(520)(711)))))(216))(692(457(731)(264))(372(846(4)(868(78(433)(303))(0(310)(211))))(311(790(151(876)(99))(181))(356(536(445)(745))(781))))))(919(736)(659(591(118(150(448(608)(362))(405))(991(485(84)(53))(964)))(611(758)(183(961(302)(811))(932(660)(977)))))(774(841)(995(332(10)(291))(963(387)(791(604)(888)))))))))(336(632(785(158)(771(554)(230(12)(510(528(812(803)(30))(504(577)(129)))(950(84)(521(626)(149)))))))(454))(226(380(215(777(654(50(965(970)(799))(556(859)(637)))(896(539(125)(419))(518(323)(687))))(504(59(674(743)(547))(490))(526(904(158)(916))(980(100)(389)))))(101(291(70(939(804)(239))(107(16)(310)))(914(364(583)(966))(333(593)(867))))(956)))(213(260)(568(407(697(761)(215(87)(576)))(598(467(555)(464))(940)))(137(613(562(256)(380))(973(194)(463)))(38(97(235)(534))(370(103)(831)))))))(779(877(268(508(434(316(812)(716))(631(905)(478)))(203))(700))(167(236)(524(846(117(676)(501))(402(71)(558)))(159(310(967)(491))(635(870)(178))))))(494(583)(54))))))) +(852(666(196(965(46(969)(50(560)(653(736(977(174)(799))(579(610)(187)))(535(224(319)(905))(659)))))(16))(823))(166(432(547(118(22(308)(222(604(187)(673))(810(780)(109))))(598(435(31)(945))(291(95(217)(110))(277(11)(311)))))(704(456(508(118(85)(886))(29))(614(497)(156(232)(940))))(768(756(268(535)(592))(302(651)(89)))(656(136(606)(255))(337)))))(5(615(988(615)(257))(289(279)(652)))(459(207(213(506(469)(919))(312(955)(974)))(210(94(775)(751))(114(374)(289))))(970))))(823(677(631)(111(23(70(252(833)(937))(96(627)(806)))(429))(849(810(700(99)(288))(809(712)(245)))(175))))(150(496(107)(967(247(953)(779(238)(795)))(707(186)(458(789)(128)))))(722(937)(694(205(529(73)(285))(608(130)(689)))(230(640(404)(451))(397(610)(485)))))))))(817(111(479)(493(640)(976)))(968(787(853(363)(810(352(620(800(398)(118))(63))(12))(35(515(828(570)(819))(866(586)(853)))(525(661(770)(93))(10(747)(545))))))(336(535(871(826)(918))(174(983)(152)))(551(175(758)(786(348(667)(264))(736(80)(377))))(471))))(338)))) +(159(588(648(580(809(334)(867))(720(992)(823(948(191(789)(447))(11(359)(278)))(932(524)(721(60)(137))))))(699(706(432)(424))(611(268(284)(505))(732))))(77(634)(587(495(920(97)(858(188(258)(356))(183(499)(877))))(374))(268(602)(266(32(176(989)(520))(615(969)(852)))(864(507)(112)))))))(141(659(312(679)(919(995)(909)))(188(274(613(941(33(898)(115))(664(417)(577)))(380(811(344)(209))(909(275)(408))))(103(817)(477)))(524)))(265(696(0(31)(444(296(920)(416(933)(798)))(235(869(622)(274))(401(169)(71)))))(611(515)(179)))(725(444)(536(990(419)(543(369)(498)))(141(984(858(914)(322))(340))(469(623)(285)))))))) +(336(864(658(181(900(275(751(471)(226(569)(643)))(648))(425(374(862(656(527(498(55)(653))(346(235)(476)))(438(714(588)(255))(411(829)(304))))(841(825)(327)))(210(639(586(677(84)(344))(593(334)(397)))(480))(555(30(7(941)(522))(320(862)(219)))(444(70(5)(734))(385)))))(7(553(547(466(45(793)(99))(982))(649))(244(382(782(140)(514))(664(584)(980)))(871(627)(457(816)(985)))))(705(612)(465)))))(859(44)(481(103(25)(283))(767(652)(772)))))(187(874(904)(407(225(368(745(743(32(334)(573))(337(243)(16)))(287))(380(80)(694)))(307(471(214(186(343)(653))(357(46)(263)))(845(250(20)(404))(814)))(492)))(318(602)(184(78(508(755(237)(697))(300))(12(269(860)(437))(35(952)(395))))(292(59)(173))))))(778(520)(61(146(876(761(700)(860))(525(179(275)(726(905)(322)))(438(198(574)(622))(228))))(858(365(670(485)(409(64)(234)))(213(582)(672)))(129)))(796(703(103)(49(599(219)(677(685)(280)))(210(881(922)(470))(38(421)(210)))))(266(95)(119)))))))(778(858(717)(534))(80(141(544(254(690(614(507(629)(10(300)(952)))(667(144(301)(209))(53)))(434(13(344(404)(324))(460(81)(926)))(711)))(875(51(112)(744))(875(164(686(561)(754))(866(448)(165)))(395(118(713)(700))(905(476)(590))))))(990(8(118(265(379)(543(7)(953)))(49(166(588)(695))(446)))(616(877(854(645)(206))(842(910)(94)))(9(440(734)(949))(873(555)(141)))))(532(934)(143))))(229(380)(642)))(568(820(462(665(264)(144))(840(671)(174)))(629))(731)))))(237(896(502(564(870)(392))(655(91)(821)))(448(51(63(690(471(562(296)(75(803(55)(176))(811)))(285))(837(105)(697(147)(32(984(270)(942))(180)))))(922))(922))(535(309)(421(420)(547(340(778(333(342(682)(773))(104))(684(410(822)(239))(851(768)(114))))(229(309(154(258)(459))(122))(88(661)(146(603)(508)))))(945(12(185)(792))(580(191)(396(399(728)(640))(496)))))))))(754(978(819)(263(522)(970(857(736(971)(961(126)(219(491(237)(736))(884(6)(52)))))(443(588)(973(328)(4(295)(922(5)(690))))))(466(464(223)(193))(665(940)(607(771(566(60)(804))(764(805)(19)))(31(826(212)(502))(735))))))))(335(216(662)(84(675)(410(987(823)(90))(768(625(375)(982(623(730)(312))(274)))(182)))))(375(892)(883)))))) +(577(685(6(618)(759(796)(450(498(2)(339(178)(280(991)(469))))(855(524)(759(916(197)(616))(787))))))(589(294)(184)))(930(157(636)(101(799)(349)))(703(983)(449(371(93)(739))(590(735(820(620)(972))(31))(523)))))) +(803(725(134(693(276(173(744)(147(680)(339)))(865(417(509(912)(113(923(505(82)(883))(176))(669)))(831))(922(388(330)(424(452(795(836)(21))(619(315)(562)))(104(455(168)(335))(569))))(697))))(722(896(266)(831(164(913(244(152(186)(342))(767(837)(285)))(764(655(924)(283))(707(306)(297))))(175(705(463)(177(871)(291)))(233(653)(60(706)(698)))))(601)))(339(615(626(368(682(485(608)(294))(638(458)(944)))(584(753)(754(690)(658))))(273(169)(548(205)(387))))(866))(999(620)(734(56)(269(139)(187)))))))(65))(418(8)(699(181)(343(846(769(306(78)(371(685(476)(573(435)(981)))(829)))(392))(110(763(638)(711(326(608(680)(30))(681))(205(257(337)(275))(260))))(702(133(103)(628))(610(59(971(323)(883))(368(741)(660)))(20(39)(637(424)(523)))))))(551(729(833(353(689)(263))(482))(544(498)(898(394(429(310)(93))(224(68)(996)))(773(410(321)(206))(382(854)(689))))))(961(477(987)(948(714(157(528)(742))(442(392)(673)))(378)))(319(964(947(923(811)(231))(78))(216(34(561)(536))(691)))(749(989)(793)))))))))(845(423(802(247(372(222(754)(822(238(538(820(148)(569))(83(14)(749)))(820(987(24)(795))(475)))(333(500(697(743)(402))(13))(977(894(744)(831))(728(286)(3))))))(356))(309(252(234)(69(689(813)(340))(701(153)(143(259)(422(48)(799))))))(102(103(496(30(453(291)(959))(377(533)(174)))(422(397(67)(719))(590(332)(260))))(957))(892(400(498(280(476)(834))(162))(125(467(630)(843))(221(604)(446))))(561)))))(922))(764(689(15(120(946)(743(330(596)(527))(779)))(306(947(412(717(787)(490))(906(497(849)(893))(3(433)(378))))(559(717(99(837)(414))(495))(319(623)(760))))(61(680(454(453(479)(206))(567(378)(718)))(669(193(223)(863))(188)))(332(727(577(518)(699))(866(56)(869)))(566)))))(800(860(985(205(148(141(644)(70))(35))(669(808)(191)))(440(648(384(870)(773))(217))(606)))(189(888(618(671(395)(223))(245(624)(662)))(458))(977(172)(500(340(837)(404))(848(189)(800))))))(619)))(625(424(2(876(229)(460))(243(186(741(201(218)(371))(218(473)(249)))(408(581(359)(788))(957)))(435)))(81(993(808)(983))(350)))(889(465(505(461)(670(462)(84(426(806)(377))(53))))(941(956)(551(823)(169(645(359)(643))(661)))))(544(644)(220(699(848(656)(672(163)(964)))(991))(794)))))))(67(500(240(344(375(288(923(979)(467))(191))(49))(328(451)(426)))(162(96(615)(78))(429)))(97))(512(387(310(138(735(1(749(227(983)(201))(828(691)(893)))(1(202(979)(25))(137(56)(497))))(332))(234(383(40(117)(686))(188(763(680)(955))(442)))(553(668(232(699)(219))(136(761)(530)))(81))))(618(959)(440)))(35(734(848)(641(796(503(133(290)(873))(172))(274(570(232)(809))(208(474)(588))))(871)))(486(146(694(82(655(89)(126))(222(268)(721)))(166(286(832)(166))(528(274)(860))))(609(951(420(665)(813))(841(783)(587)))(388)))(861))))(643(925(143(71)(704(542)(137(977(54)(602(103)(293)))(166(997)(327)))))(461(783)(466(545(772(584(890)(726))(462(654)(911)))(876))(251(330(776(291)(578))(545(295)(16)))(176)))))(640)))))) +(573(195(565(887(553)(947(759)(624(744)(995))))(460))(827(479(69)(436(220)(224)))(613(962)(235(134(395(96)(650(2(215)(389))(790(144)(392))))(390))(889(273)(811(124(627(832)(85))(193(540)(579)))(178(176(749)(716))(757(920)(935)))))))))(461(797(233(779(229(535(501(905(894)(663))(493(342)(123)))(266))(443(588(996(376)(964))(712))(11(735)(907(536)(937)))))(369(561(661(123(311)(172))(327))(313(107(545)(357))(701(283)(927))))(700(211)(281(378(496)(83))(719)))))(905(502(215(96)(45(651(418)(169))(846(950)(222))))(653))(499(512(177)(247))(286(309(437)(306(610)(659)))(681(21(603)(88))(336))))))(306(328(984(453)(693(975(540(857)(489))(117(735)(843)))(414(721(827)(250))(134))))(44(577)(168)))(454(999(662)(685))(745(905(977(286(648)(219))(433(105)(526)))(35(564)(112)))(368(809)(450(407)(849(82)(105))))))))(554(880(779(460(181(953(439(964)(897))(59))(929(302)(793(322)(757))))(29(947(324(921)(986))(241(237)(30)))(957(155(629)(455))(183(263)(773)))))(313(884(328)(487(151(246)(136))(316(567)(517))))(707(439)(37))))(522))(777(295(932)(649(223(699(651(542)(980))(46))(363(873(643)(427))(811(219)(314))))(970(188)(802))))(94))))) +(148(110(756(559(287)(578))(66(113(415)(320(364(636(995)(663))(101(538)(479)))(691(916(147)(404))(346))))(610(815(815(775(678)(598))(486(61)(340)))(154(578)(476)))(316(29(286(138)(871))(252(134)(609)))(116(415(708)(0))(511(213)(189)))))))(216(67)(466(999)(637(628)(83(367(636(225)(748))(779(908)(257)))(131))))))(64(826(945(229(308)(123(876(477(308)(319))(226(593)(597)))(290)))(935(931(149)(278(569(219)(357))(390(786)(615))))(151)))(957(25(950(877(90(855)(906))(692))(788(686(969)(182))(293(388)(32))))(662(63(582(900)(917))(256))(552(829(835)(955))(89))))(640(122(501(684)(152(372)(688)))(898))(9(52(528)(731))(946(26)(336(988)(581)))))))(839(307(660)(516(144(711)(605(39(489)(291))(763(359)(54))))(717(942(685)(892(52)(643)))(690(709(776)(996))(990(943)(962))))))(89)))) +(899(768(452(126)(211(769(533(767(835(530)(452(724)(998)))(473(609)(199)))(658(720(295(949(214)(990))(742))(658(361(14)(221))(739(147)(956))))(961(833(353(13)(682))(382))(505(306(5)(294))(293)))))(88(5)(60(164(151(611(920)(883))(302(478)(721)))(50(128(980)(267))(106(797)(814))))(952(524)(959(315)(595(469)(799)))))))(963)))(526(989(940(405(229(306)(310(349(38(828)(601))(887(621)(163)))(269(506(43)(386))(972))))(145(663)(545(406(682(645)(843))(48(286)(85)))(626(569(363)(994))(159(898)(324))))))(718(630(320(874)(703))(214(593(508(448)(695))(808))(945(606(725)(246))(446(949)(81)))))(246(18(695(384(595)(623))(505(772)(457)))(707(82(478)(886))(971)))(985(661)(741)))))(992))(834(313(446)(196))(325(993)(380)))))(853(668(806(258(427(645(35(568(76(935)(273))(690))(687(433(472)(548))(563(155)(118))))(597(70)(868(690)(749))))(562(124(508(43)(205))(14))(888(602(78(93)(914))(742(571)(985)))(476(663)(279(630)(219))))))(434(896(306(585(544)(862(498)(148)))(253))(719))(576(508(670(511)(939(466)(830)))(284))(138(740(646(624)(574))(29(144)(807)))(796(42(784)(264))(500(960)(447)))))))(49(713)(378(732(650)(702(783(320(538)(577))(249))(966(824(870)(272))(740(50)(339)))))(541(449)(521)))))(315))(556(330(759(648(924)(419))(968(332(146(872(999)(201))(351))(908))(253(479(863)(872(926(616)(418))(47(781)(609))))(276(570(772(137)(3))(493(137)(318)))(659(397(45)(440))(941(423)(311)))))))(3(302)(934(6(350(707(265)(372(954)(769)))(406(895)(832(274)(503))))(409(3(124)(399(223)(422)))(107(553(559)(930))(191))))(150(99(744)(784(713(291)(799))(68(905)(760))))(521(491(338(331)(519))(689(160)(261)))(471))))))(978)))) +(149(134(341(476(80(139(817)(642))(458(996(160)(784))(523)))(651(759)(412(819)(770(21)(488)))))(854(707(446(472)(722(765)(275)))(418(80(50)(193))(746(726)(241))))(430(369(450(763)(443))(737(914)(420)))(388))))(238(790)(295(554)(356))))(414(130(492(239(779(975)(105(992)(808)))(292))(89(773(468(99)(723))(688))(334)))(910(938)(650(947(266)(745(92)(143)))(344))))(82(446)(750(545(726)(275))(438(990(374)(571(418)(27)))(380)))))) +(227(232(166(722(506(717(947(527)(500))(563(67)(382)))(63(892)(954)))(665(44(330)(942(691)(618)))(465(593)(104(115)(202)))))(805(14(666)(659(256(927)(575))(536(33)(118))))(405(384(712(514)(50))(678(636)(563)))(133(938(191)(935))(246(572)(501))))))(625(942)(633(201(359(876)(296(672)(961)))(935))(772(478)(339(518)(257(119)(531)))))))(39(482(830)(738))(552(574)(230(52(396(596)(852(144)(702)))(959(35)(448(84)(280))))(478(82(764(856)(325))(235(639)(241)))(935(102)(955(903)(969)))))))) +(80(120(323(691)(921))(672(677(37(216(266(214(530)(786))(522))(440(892(374)(552))(874(459)(699))))(526(113(726)(612(381)(679)))(58(26(401)(490))(956(877)(154)))))(950(197(71)(253(687(573)(853))(873)))(94(936(179(383)(118))(916))(715(161(43)(708))(426(940)(855))))))(671(406(145(970(705(808)(61))(773))(27))(363(857(18(621)(646))(956(402)(553)))(244(997(851)(779))(877))))(229(540(684(512(98)(824))(270(0)(207)))(125))(849(489(255(375)(852))(749(328)(789)))(695))))))(943(462(816)(679(232)(737)))(83(813(553(973)(793(912)(111(744(68)(17))(751(319)(155)))))(421))(205(877(587(145(606(658)(119))(106(939)(254)))(342))(31(912(916(207)(170))(721(501)(219)))(876)))(242))))) +(361(590(696(221)(901(281(6)(151(879(581(678(61(910)(335(883)(850)))(594(951(207)(791))(305(765)(268))))(415))(620(147(147(77(408)(290))(964))(312))(306(160(401)(303(295)(310)))(623(240(822)(16))(954)))))(707(932(749(524)(421(347(502)(426))(391(359)(283))))(251(460)(422)))(152))))(901(26(82(374(22(937(669)(934(988)(456)))(849(320(362)(301))(994(929)(920))))(43(442(219)(621(470)(784)))(382)))(940(771(428)(419(888(604)(459))(545)))(262)))(103(98)(568)))(934(502(826(666)(149(746(544(937)(546))(970))(719)))(164(795(304(963)(331))(675(11(788)(417))(498(575)(876))))(785(290(137(190)(577))(282(759)(196)))(930(697(981)(532))(689(712)(899))))))(304(999(356(178)(95(356(607)(462))(949)))(970(474(38(75)(782))(665(296)(579)))(897(851(296)(235))(244(197)(831)))))(612))))))(522(581)(695(640(493(899)(657))(638(24)(186(128(325(356)(242))(271(415)(765(535(426)(625))(250))))(584(211)(876(82(51)(372(573)(200)))(54(423(34)(578))(669(121)(241))))))))(603(748(52(54)(73(322(931(897(481)(530))(872(314)(551)))(286(825(563)(898))(385(104)(872))))(949(256(34(829)(529))(310))(623))))(309(503(418(136)(331(218(926)(990))(879)))(649))(277(574(277)(762))(225(154(749(899)(415))(187(732)(587)))(713)))))(227)))))(308(903(529(654)(964(711(858)(739(417)(641(120(262(70(430)(586))(405(106)(981)))(185(198)(164(866)(279))))(196(594(708(898)(575))(955(359)(122)))(285(277(356)(940))(638(660)(861)))))))(457(717)(681(437)(199)))))(138))(858(54(193(612(808(544(865(733)(597))(598(215)(666)))(835(934)(450(103(601(482)(443))(881))(186(846)(518)))))(307(466(985(845(772(290)(104))(794))(453(986(870)(695))(367(769)(791))))(236(642(306)(411))(772(696)(198))))(783(156(744(841)(319(929)(303)))(868(711)(693)))(826(518)(49(422(71)(582))(281))))))(972))(146(808(483)(29))(51)))(18)))) +(788(640(948(971)(766))(483(209)(827)))(163(441(655)(638))(812(548(820)(913(798(680)(360(74(823(514)(470))(351(976)(887)))(576)))(537(935)(333(820(900)(256(766)(702)))(650)))))(722(234)(530(865(919(862(46(507)(813))(448))(661(946(721)(811))(927(61)(747))))(253(147(27(892)(843))(63(474)(603)))(198(279(811)(734))(85))))(378(717)(685(726(739(803)(243))(850))(995(140(902)(524))(757))))))))) +(857(510(140(224(959(282)(868(631(4(101)(627))(736(877)(858)))(358(67(502)(189))(352(957)(127)))))(261(463(110(448(380)(708))(877(11)(659)))(138(221(12)(707))(222(313)(983))))(351(42)(3))))(791(533(71)(178(246(996(22)(848))(6(160)(354)))(347(867)(633(333)(67)))))(410(963(372(274(162)(734))(401(130)(638)))(846(28)(872)))(589(341(910(158)(263))(365(715)(77)))(500(859)(746))))))(553(485(71)(463))(99(281)(522(921(683(516(461)(233))(978(908)(702)))(550))(47(364(982(725)(183))(905(14)(340)))(717))))))(520(285(761)(249(827)(526)))(723(918(371(236(158(831(846)(376))(457))(301))(150(542)(428(68(639)(471))(58(948)(370)))))(748))(811(807(284)(433(905)(870)))(517(861)(334(621)(241))))))) +(238(539(118(169(357(407(684)(763(960)(830(201)(670))))(150(34)(592(628(34)(637))(856(801)(263)))))(769(412(827(41(203)(401))(633(308)(456)))(36))(964)))(668(158)(365(60)(57))))(814(492(496)(991(669)(2(7(92(369)(446))(30(749)(636)))(732(745)(825(188)(927))))))(468(453(535(594)(918(622(444)(977))(970(912)(542))))(802))(301(993)(106(416(81(627)(262))(325(512)(341)))(570(402)(611(61)(443))))))))(837(258(572(790)(868))(369(153)(353(496(100(656)(928(951)(670)))(895))(284(447(981)(178))(815(738(46)(329))(316(533)(400)))))))(444(214)(608(972(493)(888(261(945(106)(362))(7))(541(822)(169(743)(852)))))(585(326)(986(411(863(623)(543))(406))(786(1(63)(161))(380(555)(700))))))))) +(671(793(527(312(836)(718(695(194)(835(728)(229(397(357)(551))(492(215)(707)))))(540(9(30)(333(543(393)(966))(842(319)(355))))(328(218)(830)))))(721(779)(410(234)(792(885)(268)))))(104(853)(120(439)(544))))(56(119(489(636(610(319)(963(970(490)(905))(657)))(498))(738))(138(147(514(288(913(358(868)(993))(106(753)(200)))(502(34(253)(667))(901(472)(257))))(373(191(927(249)(960))(769(976)(650)))(995(929(142)(156))(6))))(968(322(115(616)(670(469)(795)))(692))(327(892(967(882)(952))(102(796)(489)))(21(2(720)(425))(907(436)(994))))))(998(405(183(477(640(381)(485))(238(263)(417)))(490(207(900)(880))(959)))(350(707)(839(834)(350(164)(213)))))(899(401(520(759(658)(295))(952(568)(862)))(487(17(474)(87))(40)))(692)))))(594(632(489)(296))(597(233(589(461)(473(735(490)(17(566)(720)))(527(767(322)(719))(308(895)(138)))))(730))(37))))) +(33(822(142(902(619)(919(27(798(998(535)(995))(711(121)(302)))(173))(752(490)(820(139(529)(643))(780(402)(231))))))(122))(17(627(830(744)(581(387(417(758)(582))(579(522)(5)))(818(815)(351(510)(757)))))(687))(824)))(186(104(350(263(319(601(366(6)(213))(651))(328(211)(28)))(198(603)(846)))(629))(808(164)(750(461(945(968(230)(519))(1))(951))(492(939(811(611)(392))(559(952)(719)))(743(675(51)(595))(411(282)(300)))))))(724(840(440)(840(638(689(20(523)(193))(258(999)(221)))(629))(675(513)(856(904(650)(986))(564)))))(588(95)(396(476)(37(424(804(772)(698))(86(719)(158)))(96))))))) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/BaumTester.java b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/BaumTester.java new file mode 100644 index 0000000..8cc0446 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/BaumTester.java @@ -0,0 +1,2811 @@ +import static org.junit.Assert.*; +import org.junit.Test; + +/** + * Eine Testklasse für Baumalgorithmen + * + * @author Rainer Helfrich + * @version 02.11.2020 + */ +public class BaumTester +{ + @Test + public void test001() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(0)); + assertEquals(481,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(512)); + assertTrue(ba.enthaelt(596)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(510)); + assertFalse(ba.enthaelt(554)); + assertFalse(ba.enthaelt(287)); + assertFalse(ba.enthaelt(99)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(875)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(974)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(146)); + assertTrue(ba.enthaelt(366)); + assertTrue(ba.enthaelt(367)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(175)); + } + + @Test + public void test002() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(1)); + assertEquals(183,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(711)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(637)); + assertFalse(ba.enthaelt(888)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(692)); + assertTrue(ba.enthaelt(731)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(667)); + assertFalse(ba.enthaelt(549)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(825)); + assertTrue(ba.enthaelt(592)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(416)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(388)); + } + + @Test + public void test003() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(2)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(985)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(374)); + assertFalse(ba.enthaelt(304)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(67)); + assertFalse(ba.enthaelt(972)); + assertFalse(ba.enthaelt(384)); + assertFalse(ba.enthaelt(845)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(353)); + assertTrue(ba.enthaelt(656)); + assertTrue(ba.enthaelt(207)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(163)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(69)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(189)); + } + + @Test + public void test004() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(3)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(132)); + assertFalse(ba.enthaelt(921)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(395)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(141)); + assertTrue(ba.enthaelt(523)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(315)); + assertTrue(ba.enthaelt(849)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(666)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(76)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(585)); + } + + @Test + public void test005() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(4)); + assertEquals(133,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(13)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(236)); + assertFalse(ba.enthaelt(468)); + assertTrue(ba.enthaelt(428)); + assertFalse(ba.enthaelt(312)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(854)); + assertTrue(ba.enthaelt(657)); + assertTrue(ba.enthaelt(232)); + assertTrue(ba.enthaelt(659)); + assertTrue(ba.enthaelt(55)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(127)); + } + + @Test + public void test006() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(5)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(243)); + assertFalse(ba.enthaelt(248)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(285)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(187)); + assertTrue(ba.enthaelt(4)); + assertFalse(ba.enthaelt(497)); + assertTrue(ba.enthaelt(983)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(47)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(116)); + assertTrue(ba.enthaelt(287)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(165)); + assertTrue(ba.enthaelt(905)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(985)); + } + + @Test + public void test007() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(6)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(452)); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(849)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(610)); + assertFalse(ba.enthaelt(73)); + assertTrue(ba.enthaelt(472)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(704)); + assertTrue(ba.enthaelt(828)); + assertTrue(ba.enthaelt(178)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(341)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(916)); + assertTrue(ba.enthaelt(227)); + } + + @Test + public void test008() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(7)); + assertEquals(389,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(772)); + assertFalse(ba.enthaelt(426)); + assertFalse(ba.enthaelt(953)); + assertTrue(ba.enthaelt(319)); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(417)); + assertTrue(ba.enthaelt(883)); + assertTrue(ba.enthaelt(657)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(80)); + assertFalse(ba.enthaelt(183)); + assertFalse(ba.enthaelt(318)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(412)); + assertFalse(ba.enthaelt(145)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(572)); + assertTrue(ba.enthaelt(208)); + } + + @Test + public void test009() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(8)); + assertEquals(159,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(746)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(850)); + assertFalse(ba.enthaelt(267)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(1009)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(166)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(25)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(709)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(853)); + assertTrue(ba.enthaelt(628)); + assertTrue(ba.enthaelt(202)); + } + + @Test + public void test010() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(9)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(993)); + assertTrue(ba.enthaelt(904)); + assertFalse(ba.enthaelt(211)); + assertTrue(ba.enthaelt(845)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(544)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(852)); + assertFalse(ba.enthaelt(65)); + assertTrue(ba.enthaelt(805)); + assertTrue(ba.enthaelt(224)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(604)); + assertTrue(ba.enthaelt(273)); + assertTrue(ba.enthaelt(161)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(590)); + } + + @Test + public void test011() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(10)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(895)); + assertTrue(ba.enthaelt(344)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(181)); + assertFalse(ba.enthaelt(661)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(54)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(690)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(185)); + assertFalse(ba.enthaelt(657)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(907)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(348)); + } + + @Test + public void test012() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(11)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(42)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(650)); + assertTrue(ba.enthaelt(61)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(1013)); + assertFalse(ba.enthaelt(368)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(559)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(987)); + assertTrue(ba.enthaelt(582)); + assertTrue(ba.enthaelt(845)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(656)); + } + + @Test + public void test013() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(12)); + assertEquals(171,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(146)); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(114)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(51)); + assertFalse(ba.enthaelt(399)); + assertFalse(ba.enthaelt(43)); + assertTrue(ba.enthaelt(595)); + assertTrue(ba.enthaelt(831)); + assertFalse(ba.enthaelt(259)); + assertTrue(ba.enthaelt(960)); + assertTrue(ba.enthaelt(919)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(394)); + assertTrue(ba.enthaelt(466)); + assertTrue(ba.enthaelt(459)); + assertTrue(ba.enthaelt(539)); + } + + @Test + public void test014() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(13)); + assertEquals(135,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(870)); + assertFalse(ba.enthaelt(978)); + assertFalse(ba.enthaelt(871)); + assertFalse(ba.enthaelt(669)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(480)); + assertTrue(ba.enthaelt(449)); + assertFalse(ba.enthaelt(380)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(436)); + assertTrue(ba.enthaelt(120)); + assertTrue(ba.enthaelt(433)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(993)); + } + + @Test + public void test015() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(14)); + assertEquals(101,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(583)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(157)); + assertFalse(ba.enthaelt(170)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(458)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(727)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(155)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test016() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(15)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(796)); + assertFalse(ba.enthaelt(842)); + assertFalse(ba.enthaelt(853)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(736)); + assertFalse(ba.enthaelt(76)); + assertFalse(ba.enthaelt(325)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(483)); + assertTrue(ba.enthaelt(190)); + assertTrue(ba.enthaelt(590)); + assertTrue(ba.enthaelt(16)); + assertTrue(ba.enthaelt(534)); + assertTrue(ba.enthaelt(762)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(775)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(760)); + } + + @Test + public void test017() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(16)); + assertEquals(95,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(745)); + assertTrue(ba.enthaelt(293)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(180)); + assertFalse(ba.enthaelt(188)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(356)); + assertFalse(ba.enthaelt(973)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(54)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(520)); + assertTrue(ba.enthaelt(429)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(194)); + } + + @Test + public void test018() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(17)); + assertEquals(315,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(837)); + assertTrue(ba.enthaelt(543)); + assertFalse(ba.enthaelt(696)); + assertFalse(ba.enthaelt(307)); + assertTrue(ba.enthaelt(140)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(405)); + assertFalse(ba.enthaelt(178)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(418)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(997)); + assertTrue(ba.enthaelt(534)); + } + + @Test + public void test019() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(18)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(709)); + assertFalse(ba.enthaelt(22)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(892)); + assertFalse(ba.enthaelt(176)); + assertFalse(ba.enthaelt(680)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(198)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(917)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(98)); + assertTrue(ba.enthaelt(521)); + assertTrue(ba.enthaelt(586)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(197)); + } + + @Test + public void test020() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(19)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(471)); + assertFalse(ba.enthaelt(742)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(682)); + assertFalse(ba.enthaelt(336)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(895)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(495)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(853)); + } + + @Test + public void test021() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(20)); + assertEquals(279,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(439)); + assertTrue(ba.enthaelt(687)); + assertFalse(ba.enthaelt(216)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(516)); + assertTrue(ba.enthaelt(335)); + assertFalse(ba.enthaelt(703)); + assertTrue(ba.enthaelt(132)); + assertTrue(ba.enthaelt(630)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(606)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(422)); + assertFalse(ba.enthaelt(43)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(410)); + assertTrue(ba.enthaelt(235)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test022() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(21)); + assertEquals(215,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(310)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(474)); + assertFalse(ba.enthaelt(123)); + assertTrue(ba.enthaelt(824)); + assertFalse(ba.enthaelt(756)); + assertFalse(ba.enthaelt(829)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(755)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(662)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(195)); + assertTrue(ba.enthaelt(365)); + assertTrue(ba.enthaelt(889)); + } + + @Test + public void test023() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(22)); + assertEquals(107,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(821)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(884)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(545)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(435)); + assertFalse(ba.enthaelt(493)); + assertFalse(ba.enthaelt(823)); + assertFalse(ba.enthaelt(355)); + assertTrue(ba.enthaelt(276)); + assertTrue(ba.enthaelt(84)); + assertTrue(ba.enthaelt(265)); + assertTrue(ba.enthaelt(140)); + assertTrue(ba.enthaelt(529)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(724)); + assertTrue(ba.enthaelt(352)); + } + + @Test + public void test024() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(23)); + assertEquals(207,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(268)); + assertFalse(ba.enthaelt(332)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(666)); + assertTrue(ba.enthaelt(36)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(537)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(941)); + assertTrue(ba.enthaelt(665)); + assertTrue(ba.enthaelt(967)); + assertTrue(ba.enthaelt(667)); + assertTrue(ba.enthaelt(684)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(800)); + } + + @Test + public void test025() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(24)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(197)); + assertFalse(ba.enthaelt(983)); + assertFalse(ba.enthaelt(470)); + assertFalse(ba.enthaelt(487)); + assertTrue(ba.enthaelt(44)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(714)); + assertFalse(ba.enthaelt(623)); + assertTrue(ba.enthaelt(18)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(864)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(488)); + } + + @Test + public void test026() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(25)); + assertEquals(247,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(999)); + assertTrue(ba.enthaelt(173)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(892)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(919)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(4)); + assertFalse(ba.enthaelt(462)); + assertFalse(ba.enthaelt(877)); + assertFalse(ba.enthaelt(568)); + assertTrue(ba.enthaelt(834)); + assertTrue(ba.enthaelt(382)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(575)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(528)); + } + + @Test + public void test027() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(26)); + assertEquals(179,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(626)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(365)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(366)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(900)); + assertTrue(ba.enthaelt(496)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(391)); + assertFalse(ba.enthaelt(801)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(310)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(262)); + assertTrue(ba.enthaelt(513)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(403)); + } + + @Test + public void test028() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(27)); + assertEquals(209,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(627)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(364)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(173)); + assertFalse(ba.enthaelt(257)); + assertFalse(ba.enthaelt(277)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(896)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(706)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(480)); + assertTrue(ba.enthaelt(926)); + assertTrue(ba.enthaelt(832)); + assertTrue(ba.enthaelt(271)); + } + + @Test + public void test029() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(28)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(942)); + assertTrue(ba.enthaelt(924)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(528)); + assertFalse(ba.enthaelt(495)); + assertFalse(ba.enthaelt(262)); + assertFalse(ba.enthaelt(413)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(230)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(758)); + assertTrue(ba.enthaelt(91)); + assertTrue(ba.enthaelt(995)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(62)); + } + + @Test + public void test030() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(29)); + assertEquals(71,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(846)); + assertFalse(ba.enthaelt(828)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(456)); + assertFalse(ba.enthaelt(424)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(908)); + assertFalse(ba.enthaelt(200)); + assertFalse(ba.enthaelt(463)); + assertFalse(ba.enthaelt(246)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(553)); + assertTrue(ba.enthaelt(223)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(222)); + assertTrue(ba.enthaelt(806)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(10)); + } + + @Test + public void test031() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(30)); + assertEquals(109,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(154)); + assertFalse(ba.enthaelt(1000)); + assertTrue(ba.enthaelt(355)); + assertFalse(ba.enthaelt(960)); + assertFalse(ba.enthaelt(301)); + assertFalse(ba.enthaelt(94)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(440)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(71)); + assertFalse(ba.enthaelt(44)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(752)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(122)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(923)); + assertTrue(ba.enthaelt(689)); + } + + @Test + public void test032() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(31)); + assertEquals(87,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(866)); + assertTrue(ba.enthaelt(304)); + assertFalse(ba.enthaelt(623)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(761)); + assertTrue(ba.enthaelt(206)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(769)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(622)); + assertTrue(ba.enthaelt(61)); + assertTrue(ba.enthaelt(409)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(30)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(868)); + assertTrue(ba.enthaelt(36)); + } + + @Test + public void test033() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(32)); + assertEquals(521,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(211)); + assertFalse(ba.enthaelt(231)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(324)); + assertTrue(ba.enthaelt(851)); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(15)); + assertFalse(ba.enthaelt(223)); + assertTrue(ba.enthaelt(553)); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(419)); + assertFalse(ba.enthaelt(90)); + assertFalse(ba.enthaelt(221)); + assertFalse(ba.enthaelt(670)); + assertTrue(ba.enthaelt(876)); + assertFalse(ba.enthaelt(902)); + } + + @Test + public void test034() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(33)); + assertEquals(59,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(617)); + assertFalse(ba.enthaelt(253)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(190)); + assertFalse(ba.enthaelt(779)); + assertFalse(ba.enthaelt(994)); + assertFalse(ba.enthaelt(941)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(351)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(230)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(705)); + } + + @Test + public void test035() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(34)); + assertEquals(107,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(238)); + assertFalse(ba.enthaelt(35)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(137)); + assertTrue(ba.enthaelt(243)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(422)); + assertFalse(ba.enthaelt(930)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(251)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(206)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(79)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(384)); + assertTrue(ba.enthaelt(665)); + } + + @Test + public void test036() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(35)); + assertEquals(93,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(413)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(427)); + assertFalse(ba.enthaelt(660)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(191)); + assertTrue(ba.enthaelt(93)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(700)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test037() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(36)); + assertEquals(175,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(833)); + assertFalse(ba.enthaelt(408)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(559)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(281)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(920)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(726)); + assertFalse(ba.enthaelt(659)); + assertFalse(ba.enthaelt(786)); + assertFalse(ba.enthaelt(876)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(901)); + assertTrue(ba.enthaelt(260)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(782)); + } + + @Test + public void test038() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(37)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(947)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(185)); + assertTrue(ba.enthaelt(255)); + assertFalse(ba.enthaelt(684)); + assertTrue(ba.enthaelt(393)); + assertTrue(ba.enthaelt(88)); + assertFalse(ba.enthaelt(633)); + assertFalse(ba.enthaelt(220)); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(686)); + assertFalse(ba.enthaelt(579)); + assertTrue(ba.enthaelt(501)); + assertTrue(ba.enthaelt(616)); + assertTrue(ba.enthaelt(389)); + assertTrue(ba.enthaelt(285)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(253)); + } + + @Test + public void test039() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(38)); + assertEquals(129,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(572)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(116)); + assertFalse(ba.enthaelt(524)); + assertFalse(ba.enthaelt(569)); + assertFalse(ba.enthaelt(1)); + assertFalse(ba.enthaelt(794)); + assertFalse(ba.enthaelt(300)); + assertFalse(ba.enthaelt(865)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(408)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(154)); + assertTrue(ba.enthaelt(734)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(284)); + assertTrue(ba.enthaelt(628)); + } + + @Test + public void test040() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(39)); + assertEquals(281,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(848)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(878)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(38)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(634)); + assertFalse(ba.enthaelt(577)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(300)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(476)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(851)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(244)); + assertTrue(ba.enthaelt(401)); + } + + @Test + public void test041() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(40)); + assertEquals(117,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(517)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(382)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(733)); + assertTrue(ba.enthaelt(847)); + assertFalse(ba.enthaelt(741)); + assertFalse(ba.enthaelt(868)); + assertFalse(ba.enthaelt(785)); + assertTrue(ba.enthaelt(544)); + assertTrue(ba.enthaelt(302)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(449)); + assertTrue(ba.enthaelt(620)); + assertTrue(ba.enthaelt(465)); + assertTrue(ba.enthaelt(587)); + } + + @Test + public void test042() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(41)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(287)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(225)); + assertFalse(ba.enthaelt(224)); + assertTrue(ba.enthaelt(994)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(488)); + assertFalse(ba.enthaelt(746)); + assertTrue(ba.enthaelt(179)); + assertTrue(ba.enthaelt(1)); + assertTrue(ba.enthaelt(903)); + assertTrue(ba.enthaelt(522)); + assertTrue(ba.enthaelt(407)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(156)); + } + + @Test + public void test043() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(42)); + assertEquals(157,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(608)); + assertTrue(ba.enthaelt(375)); + assertFalse(ba.enthaelt(689)); + assertFalse(ba.enthaelt(856)); + assertTrue(ba.enthaelt(139)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(887)); + assertFalse(ba.enthaelt(481)); + assertFalse(ba.enthaelt(256)); + assertFalse(ba.enthaelt(182)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(114)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(744)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(362)); + assertTrue(ba.enthaelt(755)); + } + + @Test + public void test044() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(43)); + assertEquals(347,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(357)); + assertFalse(ba.enthaelt(718)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(58)); + assertFalse(ba.enthaelt(313)); + assertFalse(ba.enthaelt(530)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(402)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(751)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(220)); + assertFalse(ba.enthaelt(835)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(859)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(237)); + } + + @Test + public void test045() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(44)); + assertEquals(459,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(126)); + assertFalse(ba.enthaelt(328)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(597)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(747)); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(93)); + assertFalse(ba.enthaelt(866)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(228)); + assertTrue(ba.enthaelt(241)); + assertTrue(ba.enthaelt(335)); + assertTrue(ba.enthaelt(257)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(498)); + assertTrue(ba.enthaelt(366)); + } + + @Test + public void test046() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(45)); + assertEquals(187,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(916)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(361)); + assertFalse(ba.enthaelt(635)); + assertFalse(ba.enthaelt(991)); + assertTrue(ba.enthaelt(308)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(203)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(992)); + assertTrue(ba.enthaelt(72)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(357)); + assertTrue(ba.enthaelt(535)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(526)); + assertTrue(ba.enthaelt(483)); + } + + @Test + public void test047() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(46)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(174)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(522)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(578)); + assertTrue(ba.enthaelt(157)); + assertTrue(ba.enthaelt(830)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(307)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(23)); + } + + @Test + public void test048() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(47)); + assertEquals(81,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(763)); + assertFalse(ba.enthaelt(697)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(516)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(331)); + assertFalse(ba.enthaelt(602)); + assertFalse(ba.enthaelt(952)); + assertFalse(ba.enthaelt(928)); + assertTrue(ba.enthaelt(794)); + assertTrue(ba.enthaelt(342)); + assertTrue(ba.enthaelt(551)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(532)); + assertTrue(ba.enthaelt(86)); + assertTrue(ba.enthaelt(217)); + assertTrue(ba.enthaelt(921)); + assertTrue(ba.enthaelt(115)); + assertTrue(ba.enthaelt(32)); + } + + @Test + public void test049() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(48)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(394)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(400)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(569)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(1008)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(902)); + assertTrue(ba.enthaelt(41)); + assertFalse(ba.enthaelt(631)); + assertFalse(ba.enthaelt(927)); + assertTrue(ba.enthaelt(790)); + assertTrue(ba.enthaelt(464)); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(203)); + assertTrue(ba.enthaelt(774)); + } + + @Test + public void test050() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(49)); + assertEquals(73,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(942)); + assertFalse(ba.enthaelt(310)); + assertFalse(ba.enthaelt(44)); + assertFalse(ba.enthaelt(536)); + assertFalse(ba.enthaelt(512)); + assertTrue(ba.enthaelt(257)); + assertFalse(ba.enthaelt(219)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(474)); + assertTrue(ba.enthaelt(21)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(358)); + assertFalse(ba.enthaelt(651)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(309)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(502)); + } + + @Test + public void test051() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(50)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(199)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(721)); + assertFalse(ba.enthaelt(396)); + assertFalse(ba.enthaelt(318)); + assertFalse(ba.enthaelt(625)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(324)); + assertFalse(ba.enthaelt(913)); + assertTrue(ba.enthaelt(869)); + assertTrue(ba.enthaelt(541)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(937)); + assertTrue(ba.enthaelt(837)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(843)); + assertTrue(ba.enthaelt(236)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(752)); + } + + @Test + public void test052() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(51)); + assertEquals(437,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(352)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(708)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(281)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(410)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(555)); + assertFalse(ba.enthaelt(1004)); + assertFalse(ba.enthaelt(768)); + assertFalse(ba.enthaelt(774)); + assertTrue(ba.enthaelt(491)); + assertTrue(ba.enthaelt(589)); + assertFalse(ba.enthaelt(360)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(871)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(918)); + } + + @Test + public void test053() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(52)); + assertEquals(209,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(933)); + assertFalse(ba.enthaelt(77)); + assertFalse(ba.enthaelt(844)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(208)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(171)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(44)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(488)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(574)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(150)); + } + + @Test + public void test054() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(53)); + assertEquals(151,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(254)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(119)); + assertFalse(ba.enthaelt(605)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(738)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(27)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(1003)); + assertFalse(ba.enthaelt(971)); + assertFalse(ba.enthaelt(283)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(159)); + assertTrue(ba.enthaelt(505)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(126)); + } + + @Test + public void test055() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(54)); + assertEquals(311,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(619)); + assertTrue(ba.enthaelt(583)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(436)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(587)); + assertTrue(ba.enthaelt(880)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(225)); + assertFalse(ba.enthaelt(460)); + assertFalse(ba.enthaelt(501)); + assertFalse(ba.enthaelt(286)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(589)); + assertFalse(ba.enthaelt(773)); + assertTrue(ba.enthaelt(912)); + assertTrue(ba.enthaelt(671)); + assertTrue(ba.enthaelt(245)); + assertTrue(ba.enthaelt(145)); + } + + @Test + public void test056() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(55)); + assertEquals(93,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(232)); + assertFalse(ba.enthaelt(504)); + assertFalse(ba.enthaelt(951)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(575)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(255)); + assertFalse(ba.enthaelt(913)); + assertFalse(ba.enthaelt(592)); + assertFalse(ba.enthaelt(649)); + assertTrue(ba.enthaelt(897)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(128)); + assertTrue(ba.enthaelt(228)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(497)); + assertTrue(ba.enthaelt(317)); + assertTrue(ba.enthaelt(269)); + } + + @Test + public void test057() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(56)); + assertEquals(499,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(557)); + assertFalse(ba.enthaelt(863)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(116)); + assertFalse(ba.enthaelt(841)); + assertTrue(ba.enthaelt(683)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(783)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(87)); + assertTrue(ba.enthaelt(983)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(354)); + assertFalse(ba.enthaelt(155)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(725)); + assertTrue(ba.enthaelt(786)); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(1009)); + } + + @Test + public void test058() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(57)); + assertEquals(243,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(1004)); + assertTrue(ba.enthaelt(633)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(998)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(365)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(517)); + assertTrue(ba.enthaelt(242)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(337)); + assertTrue(ba.enthaelt(347)); + assertTrue(ba.enthaelt(133)); + } + + @Test + public void test059() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(58)); + assertEquals(875,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(665)); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(490)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(975)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(789)); + assertFalse(ba.enthaelt(625)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(818)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(566)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(886)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(463)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(84)); + } + + @Test + public void test060() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(59)); + assertEquals(251,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(81)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(998)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(1000)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(570)); + assertFalse(ba.enthaelt(104)); + assertTrue(ba.enthaelt(495)); + assertFalse(ba.enthaelt(584)); + assertFalse(ba.enthaelt(560)); + assertTrue(ba.enthaelt(623)); + assertFalse(ba.enthaelt(1005)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(360)); + assertTrue(ba.enthaelt(630)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(469)); + } + + @Test + public void test061() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(60)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(432)); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(998)); + assertTrue(ba.enthaelt(9)); + assertFalse(ba.enthaelt(940)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(951)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(392)); + assertTrue(ba.enthaelt(226)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(350)); + assertTrue(ba.enthaelt(799)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(836)); + } + + @Test + public void test062() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(61)); + assertEquals(85,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(192)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(869)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(3)); + assertTrue(ba.enthaelt(634)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(785)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(414)); + assertTrue(ba.enthaelt(579)); + } + + @Test + public void test063() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(62)); + assertEquals(221,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(251)); + assertFalse(ba.enthaelt(138)); + assertTrue(ba.enthaelt(803)); + assertFalse(ba.enthaelt(280)); + assertFalse(ba.enthaelt(62)); + assertFalse(ba.enthaelt(665)); + assertFalse(ba.enthaelt(429)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(656)); + assertTrue(ba.enthaelt(463)); + assertFalse(ba.enthaelt(131)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(26)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(167)); + assertTrue(ba.enthaelt(399)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(944)); + assertTrue(ba.enthaelt(625)); + } + + @Test + public void test064() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(63)); + assertEquals(115,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(690)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(525)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(28)); + assertFalse(ba.enthaelt(622)); + assertFalse(ba.enthaelt(270)); + assertFalse(ba.enthaelt(731)); + assertTrue(ba.enthaelt(38)); + assertTrue(ba.enthaelt(479)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(24)); + assertTrue(ba.enthaelt(754)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(289)); + } + + @Test + public void test065() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(64)); + assertEquals(513,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(579)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(598)); + assertFalse(ba.enthaelt(303)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(776)); + assertFalse(ba.enthaelt(522)); + assertTrue(ba.enthaelt(323)); + assertFalse(ba.enthaelt(168)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(922)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(113)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(866)); + } + + @Test + public void test066() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(65)); + assertEquals(79,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(441)); + assertTrue(ba.enthaelt(976)); + assertFalse(ba.enthaelt(797)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(159)); + assertFalse(ba.enthaelt(305)); + assertFalse(ba.enthaelt(486)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(216)); + assertTrue(ba.enthaelt(696)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(225)); + } + + @Test + public void test067() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(66)); + assertEquals(145,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(588)); + assertFalse(ba.enthaelt(860)); + assertTrue(ba.enthaelt(451)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(634)); + assertFalse(ba.enthaelt(154)); + assertTrue(ba.enthaelt(146)); + assertFalse(ba.enthaelt(581)); + assertFalse(ba.enthaelt(778)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(580)); + assertFalse(ba.enthaelt(685)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(106)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(173)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(249)); + assertTrue(ba.enthaelt(244)); + } + + @Test + public void test068() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(67)); + assertEquals(653,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(950)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(543)); + assertTrue(ba.enthaelt(161)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(135)); + assertTrue(ba.enthaelt(119)); + assertTrue(ba.enthaelt(379)); + assertFalse(ba.enthaelt(9)); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(634)); + assertTrue(ba.enthaelt(215)); + assertFalse(ba.enthaelt(345)); + assertTrue(ba.enthaelt(326)); + assertFalse(ba.enthaelt(948)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(803)); + assertTrue(ba.enthaelt(463)); + assertTrue(ba.enthaelt(212)); + } + + @Test + public void test069() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(68)); + assertEquals(231,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(343)); + assertFalse(ba.enthaelt(195)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(377)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(643)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(771)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(198)); + } + + @Test + public void test070() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(69)); + assertEquals(241,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(982)); + assertFalse(ba.enthaelt(326)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(71)); + assertFalse(ba.enthaelt(494)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(915)); + assertTrue(ba.enthaelt(100)); + assertFalse(ba.enthaelt(215)); + assertFalse(ba.enthaelt(48)); + assertFalse(ba.enthaelt(5)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(908)); + assertTrue(ba.enthaelt(451)); + assertTrue(ba.enthaelt(258)); + assertTrue(ba.enthaelt(473)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(734)); + } + + @Test + public void test071() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(70)); + assertEquals(147,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(803)); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(464)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(439)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(494)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(113)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(644)); + assertTrue(ba.enthaelt(537)); + assertTrue(ba.enthaelt(471)); + assertTrue(ba.enthaelt(70)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(581)); + } + + @Test + public void test072() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(71)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(675)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(105)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(328)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(466)); + assertFalse(ba.enthaelt(572)); + assertTrue(ba.enthaelt(499)); + assertFalse(ba.enthaelt(218)); + assertTrue(ba.enthaelt(518)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(32)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(152)); + assertTrue(ba.enthaelt(19)); + } + + @Test + public void test073() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(72)); + assertEquals(231,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(908)); + assertTrue(ba.enthaelt(138)); + assertFalse(ba.enthaelt(1012)); + assertFalse(ba.enthaelt(189)); + assertTrue(ba.enthaelt(745)); + assertFalse(ba.enthaelt(799)); + assertTrue(ba.enthaelt(922)); + assertTrue(ba.enthaelt(595)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(31)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(348)); + assertTrue(ba.enthaelt(850)); + assertTrue(ba.enthaelt(162)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(388)); + assertTrue(ba.enthaelt(694)); + } + + @Test + public void test074() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(73)); + assertEquals(191,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(92)); + assertFalse(ba.enthaelt(929)); + assertTrue(ba.enthaelt(312)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(529)); + assertFalse(ba.enthaelt(567)); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(788)); + assertTrue(ba.enthaelt(487)); + assertTrue(ba.enthaelt(330)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(77)); + assertTrue(ba.enthaelt(624)); + assertTrue(ba.enthaelt(722)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(215)); + } + + @Test + public void test075() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(74)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(561)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(230)); + assertFalse(ba.enthaelt(40)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(624)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(394)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(951)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(364)); + assertTrue(ba.enthaelt(293)); + assertTrue(ba.enthaelt(58)); + assertTrue(ba.enthaelt(798)); + assertTrue(ba.enthaelt(51)); + } + + @Test + public void test076() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(75)); + assertEquals(63,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(251)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(214)); + assertFalse(ba.enthaelt(963)); + assertFalse(ba.enthaelt(921)); + assertTrue(ba.enthaelt(278)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(302)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(640)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(419)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(385)); + } + + @Test + public void test077() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(76)); + assertEquals(265,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(59)); + assertTrue(ba.enthaelt(384)); + assertFalse(ba.enthaelt(286)); + assertTrue(ba.enthaelt(195)); + assertFalse(ba.enthaelt(432)); + assertTrue(ba.enthaelt(591)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(867)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(981)); + assertFalse(ba.enthaelt(32)); + assertFalse(ba.enthaelt(782)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(804)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(129)); + assertTrue(ba.enthaelt(483)); + assertTrue(ba.enthaelt(372)); + } + + @Test + public void test078() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(77)); + assertEquals(211,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(520)); + assertFalse(ba.enthaelt(832)); + assertTrue(ba.enthaelt(98)); + assertFalse(ba.enthaelt(240)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(237)); + assertFalse(ba.enthaelt(873)); + assertFalse(ba.enthaelt(672)); + assertFalse(ba.enthaelt(269)); + assertTrue(ba.enthaelt(115)); + assertFalse(ba.enthaelt(493)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(766)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(519)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(114)); + } + + @Test + public void test079() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(78)); + assertEquals(77,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(274)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(175)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(191)); + assertFalse(ba.enthaelt(640)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(950)); + assertTrue(ba.enthaelt(14)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(402)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(747)); + } + + @Test + public void test080() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(79)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(89)); + assertTrue(ba.enthaelt(366)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(825)); + assertFalse(ba.enthaelt(289)); + assertFalse(ba.enthaelt(1016)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(326)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(239)); + assertTrue(ba.enthaelt(139)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(286)); + } + + @Test + public void test081() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(80)); + assertEquals(577,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(821)); + assertFalse(ba.enthaelt(446)); + assertTrue(ba.enthaelt(748)); + assertFalse(ba.enthaelt(400)); + assertTrue(ba.enthaelt(505)); + assertFalse(ba.enthaelt(898)); + assertTrue(ba.enthaelt(10)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(222)); + assertFalse(ba.enthaelt(977)); + assertTrue(ba.enthaelt(555)); + assertTrue(ba.enthaelt(870)); + assertFalse(ba.enthaelt(845)); + assertTrue(ba.enthaelt(795)); + assertTrue(ba.enthaelt(12)); + assertTrue(ba.enthaelt(233)); + assertFalse(ba.enthaelt(731)); + } + + @Test + public void test082() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(81)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(508)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(770)); + assertFalse(ba.enthaelt(1010)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(15)); + assertTrue(ba.enthaelt(418)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(299)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(768)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(629)); + assertTrue(ba.enthaelt(844)); + } + + @Test + public void test083() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(82)); + assertEquals(393,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(560)); + assertFalse(ba.enthaelt(646)); + assertTrue(ba.enthaelt(558)); + assertFalse(ba.enthaelt(8)); + assertFalse(ba.enthaelt(683)); + assertFalse(ba.enthaelt(805)); + assertTrue(ba.enthaelt(668)); + assertTrue(ba.enthaelt(434)); + assertTrue(ba.enthaelt(483)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(137)); + assertTrue(ba.enthaelt(239)); + assertFalse(ba.enthaelt(747)); + assertTrue(ba.enthaelt(583)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(717)); + } + + @Test + public void test084() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(83)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(805)); + assertFalse(ba.enthaelt(725)); + assertFalse(ba.enthaelt(434)); + assertTrue(ba.enthaelt(289)); + assertFalse(ba.enthaelt(330)); + assertTrue(ba.enthaelt(130)); + assertFalse(ba.enthaelt(876)); + assertFalse(ba.enthaelt(812)); + assertFalse(ba.enthaelt(989)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(594)); + assertTrue(ba.enthaelt(673)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(940)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test085() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(84)); + assertEquals(123,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(332)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(197)); + assertTrue(ba.enthaelt(188)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(59)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(200)); + assertTrue(ba.enthaelt(265)); + assertFalse(ba.enthaelt(320)); + assertTrue(ba.enthaelt(969)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(190)); + assertTrue(ba.enthaelt(664)); + assertFalse(ba.enthaelt(1010)); + assertTrue(ba.enthaelt(340)); + assertTrue(ba.enthaelt(679)); + assertTrue(ba.enthaelt(909)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(416)); + } + + @Test + public void test086() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(85)); + assertEquals(425,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(406)); + assertFalse(ba.enthaelt(372)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(108)); + assertFalse(ba.enthaelt(158)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(581)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(692)); + assertFalse(ba.enthaelt(127)); + assertTrue(ba.enthaelt(593)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(492)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(90)); + assertTrue(ba.enthaelt(457)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(209)); + assertTrue(ba.enthaelt(180)); + } + + @Test + public void test087() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(86)); + assertEquals(43,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(247)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(117)); + assertFalse(ba.enthaelt(733)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(530)); + assertFalse(ba.enthaelt(363)); + assertFalse(ba.enthaelt(827)); + assertFalse(ba.enthaelt(995)); + assertFalse(ba.enthaelt(926)); + assertTrue(ba.enthaelt(294)); + assertTrue(ba.enthaelt(759)); + assertTrue(ba.enthaelt(972)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(450)); + } + + @Test + public void test088() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(87)); + assertEquals(579,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(1017)); + assertFalse(ba.enthaelt(557)); + assertTrue(ba.enthaelt(742)); + assertFalse(ba.enthaelt(95)); + assertFalse(ba.enthaelt(748)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(612)); + assertFalse(ba.enthaelt(131)); + assertTrue(ba.enthaelt(433)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(739)); + assertTrue(ba.enthaelt(831)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(368)); + assertFalse(ba.enthaelt(674)); + assertTrue(ba.enthaelt(889)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(13)); + assertTrue(ba.enthaelt(350)); + } + + @Test + public void test089() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(88)); + assertEquals(229,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(37)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(642)); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(38)); + assertFalse(ba.enthaelt(859)); + assertTrue(ba.enthaelt(324)); + assertFalse(ba.enthaelt(475)); + assertTrue(ba.enthaelt(793)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(480)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(466)); + assertTrue(ba.enthaelt(984)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(721)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(517)); + } + + @Test + public void test090() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(89)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(686)); + assertFalse(ba.enthaelt(84)); + assertFalse(ba.enthaelt(210)); + assertFalse(ba.enthaelt(541)); + assertTrue(ba.enthaelt(775)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(133)); + assertTrue(ba.enthaelt(578)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(750)); + assertFalse(ba.enthaelt(295)); + assertFalse(ba.enthaelt(19)); + assertTrue(ba.enthaelt(278)); + assertTrue(ba.enthaelt(189)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(511)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(39)); + } + + @Test + public void test091() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(90)); + assertEquals(329,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(698)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(467)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(897)); + assertTrue(ba.enthaelt(533)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(538)); + assertFalse(ba.enthaelt(142)); + assertFalse(ba.enthaelt(667)); + assertTrue(ba.enthaelt(783)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(48)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(478)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(834)); + } + + @Test + public void test092() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(91)); + assertEquals(87,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(77)); + assertTrue(ba.enthaelt(369)); + assertFalse(ba.enthaelt(596)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(899)); + assertFalse(ba.enthaelt(901)); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(785)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(98)); + assertTrue(ba.enthaelt(996)); + assertTrue(ba.enthaelt(356)); + assertTrue(ba.enthaelt(688)); + assertTrue(ba.enthaelt(746)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(92)); + assertTrue(ba.enthaelt(238)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(105)); + } + + @Test + public void test093() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(92)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(185)); + assertFalse(ba.enthaelt(447)); + assertFalse(ba.enthaelt(401)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(535)); + assertFalse(ba.enthaelt(886)); + assertFalse(ba.enthaelt(775)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(988)); + assertTrue(ba.enthaelt(67)); + assertTrue(ba.enthaelt(678)); + assertTrue(ba.enthaelt(50)); + assertTrue(ba.enthaelt(144)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(636)); + assertTrue(ba.enthaelt(633)); + assertTrue(ba.enthaelt(296)); + assertTrue(ba.enthaelt(947)); + } + + @Test + public void test094() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(93)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(965)); + assertFalse(ba.enthaelt(826)); + assertFalse(ba.enthaelt(551)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(11)); + assertFalse(ba.enthaelt(497)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(177)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(816)); + assertTrue(ba.enthaelt(26)); + assertTrue(ba.enthaelt(80)); + assertTrue(ba.enthaelt(824)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(37)); + assertTrue(ba.enthaelt(943)); + assertTrue(ba.enthaelt(363)); + } + + @Test + public void test095() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(94)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(313)); + assertTrue(ba.enthaelt(769)); + assertFalse(ba.enthaelt(74)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(473)); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(663)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(783)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(531)); + assertTrue(ba.enthaelt(625)); + assertTrue(ba.enthaelt(186)); + assertTrue(ba.enthaelt(442)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(999)); + } + + @Test + public void test096() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(95)); + assertEquals(79,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(630)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(926)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(214)); + assertTrue(ba.enthaelt(63)); + assertFalse(ba.enthaelt(329)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(934)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(256)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(441)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(333)); + } + + @Test + public void test097() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(96)); + assertEquals(141,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(98)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(15)); + assertFalse(ba.enthaelt(931)); + assertFalse(ba.enthaelt(265)); + assertFalse(ba.enthaelt(226)); + assertTrue(ba.enthaelt(639)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(150)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(281)); + assertTrue(ba.enthaelt(510)); + assertTrue(ba.enthaelt(428)); + assertTrue(ba.enthaelt(631)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(12)); + } + + @Test + public void test098() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(97)); + assertEquals(139,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(889)); + assertFalse(ba.enthaelt(987)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(33)); + assertFalse(ba.enthaelt(485)); + assertFalse(ba.enthaelt(482)); + assertFalse(ba.enthaelt(946)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(227)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(763)); + assertTrue(ba.enthaelt(63)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(57)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(401)); + assertTrue(ba.enthaelt(301)); + assertTrue(ba.enthaelt(214)); + assertTrue(ba.enthaelt(30)); + } + + @Test + public void test099() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(98)); + assertEquals(169,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(714)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(597)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(760)); + assertTrue(ba.enthaelt(610)); + assertFalse(ba.enthaelt(411)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(127)); + assertFalse(ba.enthaelt(541)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(379)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(568)); + assertTrue(ba.enthaelt(156)); + assertTrue(ba.enthaelt(882)); + assertTrue(ba.enthaelt(952)); + assertTrue(ba.enthaelt(102)); + } + + @Test + public void test100() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(99)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(307)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(273)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(697)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(387)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(396)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(28)); + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Baumalgorithmen.java b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Baumalgorithmen.java new file mode 100644 index 0000000..586d376 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Baumalgorithmen.java @@ -0,0 +1,119 @@ +import java.util.function.BiFunction; + +/** + * Führt verschiedene Algorithmen auf Binärbäumen aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Baumalgorithmen +{ + /** + * Die Wurzel des Baums, mit dem der Algorithmus durchgeführt werden soll + */ + protected Binaerbaum wurzel; + + /** + * Erzeugt ein neues Algorithmen-Objekt + * @param wurzel Die Wurzel des Baums, der verarbeitet werden soll + */ + public Baumalgorithmen(Binaerbaum wurzel) + { + this.wurzel = wurzel; + } + + /** + * Zeigt den Baum auf der Konsole an. + */ + public void baumAnzeigen() + { + if (wurzel != null) + { + System.out.println(wurzel.daten); + baumAnzeigen(wurzel.links, "", true); + baumAnzeigen(wurzel.rechts, "", false); + } + } + + private void baumAnzeigen(Binaerbaum b, String indent, boolean left) + { + System.out.print(indent); + System.out.print(left ? "\u251C " : "\u2514 "); + if (b != null) + { + System.out.println(b.daten); + if (b.links != null || b.rechts != null) + { + indent += (left ? "\u2502 " : " "); + baumAnzeigen(b.links, indent, true); + baumAnzeigen(b.rechts, indent, false); + } + } + else + { + System.out.println(""); + } + } + + /** + * Führt eine Baumtraversierung durch und wendet eine Funktion auf alle Elemente an + * @param b Der Baum, dessen Kinder traversiert werden sollen + * @param f Die Funktion, die auf die Werte angewendet werden soll + * @param neutral Das Neutralelement bezüglich der Funktion f + * @return Das Ergebnis der Traversierung + */ + private T traversierung(Binaerbaum b, BiFunction f, T neutral) + { + if (b == null) + { + return neutral; + } + return f.apply(traversierung(b.links, f, neutral), traversierung(b.rechts, f, neutral)); + } + + /** + * Gibt die Tiefe des Baums zurück + * @return Die Tiefe des Baums, gezählt ab der Wurzel + */ + public int tiefe() + { + return traversierung(wurzel, (x, y) -> 1 + Math.max(x,y), 0); + } + + /** + * Gibt die Anzahl der Knoten im Baums zurück + * @return Die Anzahl aller Knoten im Baum + */ + public int anzahl() + { + return traversierung(wurzel, (x, y) -> 1 + x + y, 0); + } + + /** + * Prüft, ob sich ein Wert im Baum befindet + * @param wert Der zu suchende Wert + * @return true, wenn ein Knoten den Wert enthält; false sonst + */ + public boolean enthaelt(T wert) + { + return enthaelt(wurzel, wert); + } + + /** + * Prüft, ob sich ein Wert in b oder darunter befindet + * @param b Der Baum, in dem der Wert gesucht werden soll + * @return true, wenn b oder einer seiner Kindknoten den Wert enthält; false sonst + */ + private boolean enthaelt(Binaerbaum b, T wert) + { + if (b == null) + { + return false; + } + if (b.daten.equals(wert)) + { + return true; + } + return enthaelt(b.links, wert) || enthaelt(b.rechts, wert); + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Binaerbaum.java b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/README.TXT b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/README.TXT new file mode 100644 index 0000000..ee5db68 Binary files /dev/null and b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/README.TXT differ diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Testbaeume.java b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Testbaeume.java new file mode 100644 index 0000000..a7f9076 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/Testbaeume.java @@ -0,0 +1,75 @@ +import java.util.ArrayList; +import java.io.FileReader; +import java.io.BufferedReader; +import java.util.ArrayList; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Liest Testbäume aus einer Datei aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Testbaeume +{ + /** + * Die aus der Datei eingelesenen Bäume + */ + static ArrayList> baeume; + + private static void readFile() + { + try + { + FileReader fileReader = new FileReader("testfaelle.txt"); + BufferedReader bufferedReader = new BufferedReader(fileReader); + baeume = new ArrayList>(); + String line = null; + while ((line = bufferedReader.readLine()) != null) { + AtomicInteger ai = new AtomicInteger(0); + Binaerbaum b = parse(line.toCharArray(), ai); + baeume.add(b); + } + bufferedReader.close(); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + baeume = null; + } + } + + private static Binaerbaum parse(char[] c, AtomicInteger s) + { + int anfang = s.incrementAndGet(); + while(c[s.get()] != '(' && c[s.get()] != ')') + { + s.incrementAndGet(); + } + String tmp = new String(c, anfang, s.get()-anfang); + int value = Integer.parseInt(tmp); + Binaerbaum ergebnis = new Binaerbaum(value); + if (c[s.get()] == '(') + { + ergebnis.links = parse(c, s); + s.incrementAndGet(); + ergebnis.rechts = parse(c, s); + s.incrementAndGet(); + } + return ergebnis; + } + + /** + * Gibt einen der Testbäume aus der Datei zurück + * @param nummer Die Nummer des Baums + * @return Den gewünschten Baum, wenn die Nummer gültig ist; null sonst + */ + public static Binaerbaum getTestBaum(int nummer) + { + if (baeume == null) + readFile(); + if (nummer >= 0 && nummer < baeume.size()) + return baeume.get(nummer); + return null; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/package.bluej b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/package.bluej new file mode 100644 index 0000000..5148e43 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/package.bluej @@ -0,0 +1,65 @@ +#BlueJ package file +dependency1.from=BaumTester +dependency1.to=Baumalgorithmen +dependency1.type=UsesDependency +dependency2.from=BaumTester +dependency2.to=Testbaeume +dependency2.type=UsesDependency +dependency3.from=Testbaeume +dependency3.to=Binaerbaum +dependency3.type=UsesDependency +dependency4.from=Baumalgorithmen +dependency4.to=Binaerbaum +dependency4.type=UsesDependency +editor.fx.0.height=872 +editor.fx.0.width=1264 +editor.fx.0.x=482 +editor.fx.0.y=73 +objectbench.height=93 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8 +package.editor.height=393 +package.editor.width=649 +package.editor.x=705 +package.editor.y=176 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=4 +package.numTargets=4 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Binaerbaum +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=170 +target1.y=60 +target2.height=50 +target2.name=Baumalgorithmen +target2.showInterface=false +target2.type=ClassTarget +target2.width=160 +target2.x=300 +target2.y=130 +target3.height=50 +target3.name=BaumTester +target3.showInterface=false +target3.type=UnitTestTargetJunit4 +target3.width=100 +target3.x=460 +target3.y=210 +target4.height=50 +target4.name=Testbaeume +target4.showInterface=false +target4.type=ClassTarget +target4.width=100 +target4.x=79 +target4.y=264 diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/testfaelle.txt b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/testfaelle.txt new file mode 100644 index 0000000..7c0595c --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/03_baumalgorithmen_HigherOrder_loes/testfaelle.txt @@ -0,0 +1,100 @@ +(366(518(665(284(101(853(360(314(190(465(386(162)(241))(459(197)(861)))(654(427(528)(255))(351(835)(533))))(445(394)(717(311)(530(253)(429)))))(756))(749(236(53(339(469(265)(695))(642(837)(192)))(860))(215))(618(340)(547(201(410)(811(37)(331)))(567)))))(130))(685(76(105(293(837)(262))(3(766)(875(161)(773(65(505)(939))(351(33)(379))))))(94))(301(90(820(166(63(931(73)(590))(936(439)(190)))(990(270(240)(807))(795)))(194(919(694)(244(430)(243)))(924)))(468(420(668)(282(73(966)(860))(270(400)(608))))(914(467)(402(915(547)(648))(96(715)(255))))))(259(870(672(733)(854(327(778)(811))(150)))(629(398(837)(333(203)(270)))(104(749(730)(534))(59(668)(940)))))(769(130)(366(408)(674)))))))(512(869(507(359(823(542)(799(713(910(693)(435))(319(663)(736)))(198)))(992))(682))(73(49)(872)))(715(628)(297))))(274(532(581(418(844)(325))(747(420(97(426(902)(991(682(440)(307))(361(493)(173))))(82(739)(645)))(493(837(182)(720(245)(817(498)(968))))(831(302)(939(429(907)(473))(914)))))(859(111(802(413(303)(291))(432(883(20)(891))(560(263)(932))))(874(85(679(130)(79))(2(761)(596)))(959(675(66)(894))(847(899)(364)))))(448))))(844(446)(690(377)(561))))(615(266)(757(612)(509(374)(641(998(367(40(223(598)(359))(129(700)(312)))(539(534(127)(583))(351(551)(108))))(276))(111(860(406(706(561)(854))(298))(680))(919))))))))(830(154(760(719(29)(9(395(471(575(625)(960(743(939)(344))(499)))(413(186(60(224)(691))(951(821)(906)))(320)))(640(555(914)(820))(910(657(725(105)(879))(896(538)(806)))(572(13(175)(254))(362(276)(664))))))(118(129(973(588)(843(20)(212(115)(2))))(300))(215(15(322)(317(144(646)(549))(411)))(50(274(452(129)(879))(454(473)(758)))(568(13(766)(542))(981(129)(211))))))))(170))(900(132(614(589(526)(550))(379(947(268(789(787(255)(889))(234))(258(112(9)(669))(593(871)(191))))(248))(451(474(35(112(436)(165))(930(550)(739)))(339(271)(745(56)(905))))(790(981)(562(33(737)(533))(648(530)(140)))))))(488))(136)))(123(832(708(637(395)(156))(360))(71(498(989(10(571)(964(248(460)(751(848)(925)))(626)))(758))(190(357(999(155)(944(210(223)(239))(687(125)(817))))(395))(593(170(119)(73(269(614)(685))(84)))(185(672)(587(80)(633))))))(198(495(107)(91(487(163(178)(628(935)(376)))(977(513)(648)))(925)))(546(595)(908(440)(557(74)(328(318(304)(292))(883(209)(198)))))))))(459(108)(358(450(817)(161))(233(503(321)(365(295)(392(811)(18(807(785)(268))(821)))))(757))))))) +(796(145(612(934(49(576)(126(436(825(199)(657))(983(245)(286)))(942(105)(545))))(42(514(577)(575(8(157)(275))(617(534)(266))))(714(783(935(907)(964))(88(376)(912)))(653(24(199)(221))(244(526)(50))))))(829(186(24(829(855(529)(692))(429(635)(202)))(932(306)(120)))(368(495)(41(566)(512(591)(478)))))(4(650(339(8(605)(714))(203(926)(92)))(480(778(367)(273))(414(4)(191))))(102(889(558(413)(379))(159(931)(866)))(514)))))(743(286(669)(277(800(656)(842))(576(680(913(429)(355))(445(51)(681)))(311))))(194)))(273(760(978(506)(240(273(592(409(521)(731))(937(463)(941)))(284))(839(932)(502(996(396)(90))(444)))))(56(620(37(872)(131(377(950)(185))(416)))(170(22(834(726)(208))(247(839)(205)))(597(103(154)(349))(810))))(109)))(886(39)(9(499(597(217)(763(530(174)(699))(257(904)(185))))(54(556(310(258)(475))(382(66)(187)))(995(958)(993(604)(14)))))(502(827)(808(131)(428(580(983)(342))(388)))))))) +(683(388(163(757)(113(798(174)(612(46(595)(66))(674(828)(41))))(837(948)(258(646(887)(334))(441(959)(15))))))(744(332(589)(551(671(661)(186(43)(947)))(681(301(229)(228))(419(887)(865)))))(207)))(954(649(258(654(185(288)(577(9)(344)))(661))(251))(435(410(565(15(469)(812))(665))(33))(917)))(770(69(985(916)(629(968)(719)))(656(628(39(481)(590))(210(705)(518)))(785(914)(995(221)(913)))))(861(435(98(150(51)(562))(343(706)(189)))(607))(219(404(741(216)(249))(423(258)(347)))(904(417(770)(210))(691(104)(997)))))))) +(163(852(819(592(619(567(235(402)(879(960)(406(195)(948))))(669(976(604(382)(740))(284))(611(837)(69(328)(239)))))(271))(870(664(295)(145(255)(36)))(876(194)(712(318(31)(915))(351)))))(475(45)(991)))(335(743(755)(441))(814(763(950(321(350)(387(947(374)(845))(38)))(849(23(344)(652(250)(120)))(988(691(304)(951))(110))))(705(909(916(751)(189))(747(450(764)(834))(394(517)(35))))(585(864)(9(673(898)(179))(76(160)(447))))))(731(392(446)(381))(540(656(864(0)(367(693)(629)))(305(0(125)(838))(535(938)(768))))(178(488(744(415)(328))(595))(422(371(6)(235))(884(7)(398)))))))))(946(361(346)(711(14(616(523(666(232(648)(755))(728))(870(901(690)(411))(864(527)(334))))(349(958)(27(805(192)(926))(986))))(311))(105(73(250)(466))(829(43(210(547(955)(206))(842(637)(520)))(690(984(704)(385))(715)))(277)))))(192(118)(909(177)(488(363(453(752(711(252)(343))(616(279)(315)))(62(250(718)(464))(853)))(280))(86(183(905)(319))(545(502(153(524)(28))(234(654)(538)))(207(202(196)(925))(751(611)(540)))))))))) +(428(369(333(668(626(728(715(766(113)(716))(358(119)(581)))(792(313(214)(593))(205)))(32(858(988(487)(810))(621(586)(659)))(252(958(882)(514))(464(532)(840)))))(290(185(646(134(972)(477))(24(20)(865)))(399))(639(98(814)(127))(285))))(598(719)(631(631(694(304(356)(372))(964))(295(295(351)(625))(950(934)(653))))(471))))(956(283)(918(849(594(297(774(27)(354))(217(657)(825)))(77(634(185)(308))(111(4)(151))))(944(344)(375(186(396)(331))(177(727)(9)))))(133))))(99(272(200(740(632)(544(484)(958(464(67)(779))(948(915)(280)))))(477(421(114)(232))(67(277)(374))))(481))(441(952)(513(805(383)(271(610(991(943)(145))(439))(614(404(885)(884))(854))))(55))))) +(954(577(3(685(175(779)(365))(287(144)(836(706(119(312)(761))(557(73)(706)))(131(270(116)(381))(780)))))(216))(325(688(803(795(820)(525(572(4)(406))(757(601)(139))))(398))(528(589(176)(624(174(924)(770))(665)))(175(131)(373(254(835)(548))(110)))))(695(329(432)(136(60(100(202)(814))(507(520)(797)))(760(51)(834(867)(706)))))(568))))(734(449(453(865(372(14(423(909)(290))(489(357)(387)))(769))(131(165(83(3)(125))(62(892)(339)))(984(948(401)(423))(211(174)(525)))))(881))(491(850(4)(984(661)(297(312(741)(482))(326))))(141(768(319)(362(514)(961(78)(74))))(429(163(214(626)(417))(955(995)(411)))(774(262(570)(615))(701(753)(589)))))))(429(438(800(925)(168(983(992(905)(385))(362))(985)))(787))(675(764)(437(426(113)(38(884(13)(940))(752(625)(850))))(754(404)(45(677)(371)))))))) +(606(112(79(954)(960(122(347)(738(153(282(599)(182(702)(486)))(625(947(281)(667))(908(737)(30))))(547(894(892(645)(443))(909(3)(250)))(382(510(87)(553))(527(891)(916))))))(513(122(687(590(644)(378(496)(371)))(384(990(33)(526))(245(28)(810))))(466))(867))))(368(44(945)(632))(609(491(319(623(672)(43(292(275)(338))(40(268)(814))))(227))(936))(438))))(230(982(227)(924))(472(274(834(642)(916(266)(910)))(39))(379(505(863(557(492(353(564)(821))(33))(903(916(976)(447))(866)))(181(461(472)(769))(471)))(831(557(779)(836))(791(595(552)(443))(424))))(409(157(449(833(371(734)(276))(253(14)(773)))(981(853(792)(647))(0)))(999(660(110)(106(904)(231)))(178(126(941)(259))(369))))(69(263(565(454(473)(83))(828(438)(494)))(249(889(822)(405))(732(470)(264))))(453(200(341)(829(952)(810)))(381(78)(822(640)(995)))))))))) +(911(409(461(415)(644(343(732(308)(141))(219))(897(809(70)(642(978(138(879(224)(511(639)(526)))(744(799(189)(993))(976(946)(792))))(723(388)(125(744)(850))))(427(56(117(402)(708(547)(664)))(179(572(615)(248))(13(590)(296))))(645(413(742(584)(789))(208(771)(254)))(601(84(191)(813))(955(871)(166)))))))(313))))(599(187)(279)))(988(300(428(234(90(964(998)(707))(383(586(754(413(130)(204))(204))(439(53)(481(369(761)(90))(790(7)(27)))))(797(651(371)(490(543(735)(681))(298)))(982))))(848(301)(195)))(320))(178(776(474(407(794)(926(766(991(543(883)(3))(452(725)(134)))(14(79)(254(189)(389))))(479(847(752(427)(229))(131(866)(13)))(56))))(159(760(980(696)(107(54)(624(247)(944))))(6(637)(641)))(699)))(993(188(93(854(51)(217(980(791)(542))(501)))(143(398(439(871)(102))(615(983)(268)))(651(17)(754))))(784(781(482(163)(568(233)(416)))(392(982(892)(797))(377(648)(516))))(920(691(654(685)(75))(539))(134(47)(334(398)(829))))))(829(174(509(692(882)(18(581)(772)))(68))(699(836(792)(243))(558(831)(935(435)(193)))))(712))))(42(677(447(116(976(326)(840(354)(300(677)(729))))(736(383(184(317)(823))(408(89)(806)))(175(556)(922))))(875(196(931)(848(286(175)(274))(428(625)(905))))(103(661(574(713)(900))(394(562)(583)))(915))))(84(940(153)(482))(561(775(890(539(164)(416))(290(763)(984)))(5))(888))))(270(52(788(412(179)(201(388)(480(585)(231))))(259(463)(542(918)(412(453)(615)))))(313))(139)))))(389(964(60(636)(456(688(33)(293(946)(310(872(915(749)(657))(544(40)(984)))(851(557(258)(322))(271(63)(619))))))(632(64(959(615(501)(760(716)(853)))(666(360(427)(5))(566(120)(108))))(234(7(834)(320(781)(838)))(169(144(798)(625))(129(969)(647)))))(154))))(378(99)(287(198(565(105(960(865(851)(354))(342))(638(742(229)(493))(731)))(165(331(317(449)(192))(838))(421(585(669)(552))(233(938)(966)))))(630))(937))))(984(785(202)(192(319(370(663)(14))(438(704(702)(299(991(474)(591))(792(27)(188))))(596)))(803)))(811))))) +(789(549(347(66)(232(216)(334(182)(771(733)(213)))))(807(391(900(181)(983(290(105)(717(802)(875(18)(266(832)(179)))))(944(487(168(221(36)(79))(513(531)(955)))(532))(397(834(826(216)(937))(761))(667(441(870)(464))(67(457)(623)))))))(403(134)(698)))(592(222(425(952)(111))(483(626(25(202)(359(735(95)(950))(428(898)(334))))(495))(239)))(21(768)(224(122(958(980(480(333)(265))(191(7)(974)))(197))(643))(900(552(454(628(925)(864))(422(345)(883)))(459))(639)))))))(215(987(991)(473))(699(657(369(69(666(555(907(220(94)(769))(765(878)(666)))(866(516(874)(942))(955(75)(348))))(117(621(193(670)(94))(343(388)(950)))(269(272(667)(787))(87(684)(161)))))(997(613)(658(853)(680(801(479)(117))(381(100)(866))))))(298))(29(993)(268(135(115(994(554)(787))(709))(56))(889))))(582(343)(698))))) +(78(894(236(464)(309(794(437(372)(581))(604(967(426(157)(869))(411(808)(462)))(361(500(698)(610))(711(184)(755)))))(623(224(102)(360(572(35)(492))(698)))(781(916(150(750)(434))(296))(33(562)(293(286)(7)))))))(334(974(756)(757(272)(867(866(772)(881(776)(845)))(470(147)(950(939)(295))))))(52(64(783(689)(848(710)(702(315)(234))))(659))(553(261(355(730)(375(945)(477)))(391(974(579)(747))(257(662)(578))))(472)))))(781(562(312(370(643(904(223)(218(273)(576)))(933(151(110)(185))(418(680)(805))))(213(766(980)(479(976)(952)))(860)))(303(383(994)(744))(117)))(477))(88(709(182)(224(431)(514)))(205(445(684(593(864)(920(184)(590)))(714(664(890)(466))(70)))(578))(161(686)(43)))))) +(625(138(24(127)(87(799(704(45(53(762(592)(632(920)(338)))(26(134(8)(482))(441)))(133))(520(326(508(762(997)(197))(209(870)(273)))(890(275(700)(789))(9)))(712(325)(968(46(210)(645))(815(185)(127))))))(711(121(742)(591(675(143(800)(138))(633))(558(157)(651))))(758(642(309(430)(276(967)(339)))(425))(295(230)(158(642(98)(146))(353))))))(917)))(792(49(249(953(481(183(753(150)(154(551)(29)))(448(589(229)(760))(83(749)(860))))(131))(91(797(135(888(470)(964))(922(762)(823)))(971))(964)))(223(152)(352(83(590(300)(861))(933(331(640)(817))(502(56)(884))))(825))))(955(767(435(343(249(170(20)(367))(27(428)(907)))(913))(87(929)(328)))(74(116(441(3(877)(146))(835(74)(135)))(829(932(263)(64))(944)))(639(794)(613(27)(815(728)(666))))))(361(184(365)(996(632(20)(69(13)(949)))(922(489(471)(348))(866(337)(627)))))(425(180(438(219)(566))(414(66(811)(674))(397)))(894(551(529(603)(462))(821(710)(544)))(900(698)(43(356)(687))))))))(321(377(200(215)(144))(784(301)(350(349)(100(725(438(366)(154))(839))(866(197(390)(902))(564))))))(729(883(737)(490(409)(118)))(366(420)(444(311(936(629(348)(205))(256(52)(904)))(461(616(47)(111))(471)))(347)))))))(460(721(848(335)(198(972(362)(934))(484(157)(656))))(431(351)(808)))(211(597(996(486(888)(429(937(139)(372(951)(951)))(500(525(954(527)(733))(888(383)(247)))(849(662)(900(941)(344))))))(903))(664))(681(250(557(681(886(694)(57(99)(660(972)(981))))(755(453(786(263)(257))(666))(818)))(62))(36(690)(721)))(27(598(478)(739))(62(968(284(954(699(592)(703))(654(816)(279)))(791))(238))(909))))))) +(406(829(52(802(122(453)(306(227)(255(601(917(640(648)(92))(878))(878))(163(343)(710)))))(830(642(812(899(875(418)(308(739)(436)))(3(186(176)(964))(937)))(829))(893(199(62)(92(388(999)(153))(114(282)(164))))(664)))(186(897(306(926)(268(369(203)(793))(454(691)(749))))(986(702(875)(414(738)(868)))(112(427(61)(334))(587))))(480(534(307(401(489)(415))(641))(37))(743(148(491)(646(38)(947)))(267(889(91)(82))(421)))))))(316))(219(235(770(183)(525(870)(447)))(134(190(796)(215))(887)))(149)))(129(934(774(646(189(430)(181(746)(163)))(750(966(411(761)(48))(151(678(459)(898(200)(87)))(122(144(821)(563))(197))))(663(710)(455(990(778(924)(343))(141(528)(67)))(810(76(888)(887))(776(111)(724)))))))(236(294(494(515(366(793(506)(851))(977(319)(577)))(394))(542))(477(15(133(492(969)(554))(313))(543(367(969)(279))(719(658)(617))))(621(0(49)(845(422)(441)))(153))))(33(115(859(18)(642(274)(48(538)(237))))(628(598)(158(745(461)(599))(696))))(650))))(876(406(931(501(274)(32(370(850(399)(724))(431(810)(376)))(441(103(918)(580))(627(259)(688)))))(444(74(643)(577(2)(799)))(572(71)(27))))(971))(856(83(110)(838(69(804)(94))(897)))(582(322(364(665)(671))(849))(364(840(485(840(185)(242))(801))(231(965(857)(670))(475(888)(381))))(961(822(762(764)(838))(519(723)(402)))(634(434(39)(742))(43(84)(110)))))))))(289(571(177(274)(823))(984(118(921)(884(408(38)(685(48(172)(393))(571(64)(434))))(47(310)(237))))(484(693(207(487(582(867)(93))(855))(56))(755))(934(665(364(600)(852(620)(625)))(393(203(734)(525))(935(470)(656))))(872)))))(899)))) +(219(539(56(513(197(904(65)(576))(252(473)(757(720(869)(574))(908))))(69))(901(115(307(671(429)(897(919)(326)))(91(452(891)(898))(993(179)(950))))(835(925(586)(838(88)(934)))(419(965)(643(70)(83)))))(247(658(866)(281(36(257)(978))(865(753)(27))))(990(262(853)(17(294)(917)))(651(866(365)(998))(419(249)(595)))))))(237(822)(470(394(606)(886(579(243(296)(255))(579))(956)))(953))))(344(508(343(515)(792(283(647(124)(611))(81(548(85)(194))(837(938)(785))))(477(265)(185(499(232)(585))(459(419)(215))))))(156(242)(966)))(117(513(107(798(603(207(759)(129))(120(650)(279)))(85(402)(907)))(911(45(208(960)(14))(732(891)(220)))(927)))(798(240(980(325)(434(223)(205)))(227(813(595)(354))(983(498)(782))))(226(51)(437(873)(255(959)(310))))))(469(545)(172(618(273)(466(808)(205(328)(755))))(835(124(286)(419))(243(742(831)(801))(417(10)(860))))))))) +(869(433(663(632(826(438)(568(22(292(183)(384))(135))(717)))(10))(618(60(291(623)(46(243(208)(665))(298)))(27(25)(563)))(493)))(956(20)(384(720(804(50)(802(214(817)(561))(865(895)(517))))(399(971(715)(872(417)(2)))(902)))(484(11(86)(130))(768(583(95(377)(465))(590))(357(943)(463)))))))(907(32(120(412(227)(138(893)(15(728(436)(300))(940(140)(668)))))(718(401)(777(106(120(940)(508))(912(753)(223)))(698(936(150)(742))(297(993)(701))))))(448(41)(357)))(742(246)(657(697(510(239(289(879)(456))(474))(631(971(970)(958))(733)))(541(449)(736(328(283)(394))(482(293)(788)))))(611(630(206)(713(999)(695(948)(401))))(723(827(919(584)(541))(286(985)(797)))(179))))))) +(784(843(954(100(546(420(21(286)(257))(488(49)(207)))(194))(523(869)(748(106(373)(657))(781))))(599))(948(961(332(105(159(884)(174))(985(759)(407)))(857(329(678)(33))(161(410)(716))))(972))(145(79(73(60)(945))(155(255)(123(518)(103))))(459))))(888(601(356(219)(59))(110(563)(102)))(983(826(727(979(862(776)(148))(807(663)(469)))(447))(926(152(613)(31))(255)))(842(662(965(401)(20(973)(888)))(667(149(774)(844))(519(332)(99))))(142(92(142(860)(526))(657(458)(557)))(128(591)(364(687)(943)))))))) +(216(85(100(562(557(730(989(657)(342))(704(985)(723)))(772(636)(203)))(655))(237(644)(917(839(676)(52(229)(412)))(486(567(128)(484))(757(531)(84))))))(16(169(545)(259))(813(970(894(29(238)(971))(313(426)(855)))(721(335)(586(609)(687))))(213(591(744(856)(18))(489))(708(355(551)(826))(210(515)(890)))))))(231(291(199(970(121(882(800)(652))(719))(953))(590(152)(229(928(200)(677))(776(211)(384)))))(902(775)(200(425)(199(543(117)(197))(762(390)(639))))))(410(953)(190(230)(310(141(534(283)(702))(760(647)(359)))(872)))))) +(285(23(900(846(994(378)(147(430(630(890)(890))(644(855)(887)))(902(522)(846(194)(193)))))(335))(812))(851(466(612(869)(534(750(115)(22))(418)))(53(54(783(862(696)(398))(103(386)(73)))(236(776(164)(213))(293(474)(774))))(828(105)(366(357(920)(322))(732(229)(80))))))(650)))(441(287(729(153(398(761)(597(565(741)(729))(136(526)(316))))(807))(516(461)(85)))(429(561)(767(641(520)(204(833)(100)))(107(370(110)(186(872)(220)))(785(122)(422(751)(293)))))))(358(806)(312)))) +(942(681(997(799)(615(618(595(78(677)(753(948(851)(552(885)(209(355)(502))))(315)))(440(85)(111)))(223(899(616(97)(174(260)(811)))(128(311(789)(974(474(519)(80))(870(596)(899))))(697)))(503(739(263(163)(586(762)(470(342)(207))))(355(282(786(693)(933))(90(160)(36)))(234)))(275(774)(444(83(431(381)(543))(458(42)(969)))(146(2)(995)))))))(244(66)(878(398(216)(273))(300(248(743)(64(549(148)(625))(304(699(801)(993))(1(734)(863)))))(509(676(316)(622(136(828)(140))(910)))(149(551(966)(693(794)(235)))(146))))))))(505(931(116(59(337(69(232(190)(936(702(146)(584))(297)))(84))(705))(346))(990))(86(7(999(637(255)(531(966(39(657)(309))(475(946)(290)))(921(137)(207(365)(190)))))(606(510)(494)))(736))(290(231(957)(441))(973))))(947(28)(438(605(487)(720(510(521(32)(73))(452))(333(810(343)(149(90(700)(275))(846(129)(279))))(102(332(717(180)(289))(598))(90)))))(731(825(815)(958))(952(566(37)(250(464(824(982)(941))(906(821)(258)))(421(2)(426(804)(763)))))(567)))))))(860(328(737)(572(891(418(869(988)(777(759(442(243)(618(777)(555)))(743))(436)))(380(200(38)(859(681(763(339)(232))(150(19)(79)))(655(623(270)(906))(988(478)(208)))))(279(50)(725))))(922(78(713(205)(769(378)(523)))(174))(533(780(251(614)(11))(152))(817(270(639)(996(773(671)(201))(648(582)(764))))(203(902)(367(313(692)(707))(767(24)(277))))))))(271(954(460)(166))(536(496(30)(68))(795(97(212(209(114(66)(378))(592(258)(304)))(344))(651(220(176(202)(27))(132(295)(14)))(995(534(284)(640))(474))))(533(471(473(860(422)(549))(357(675)(914)))(834))(515)))))))(103(569)(42)))) +(911(832(222(261(538(20(900(227)(332))(215(547(586(585(955(900)(107))(194(855)(294)))(885))(253(966(330(142)(130))(822))(246(272(242)(618))(61))))(490)))(679(725(978)(817(118)(444)))(12(290)(448))))(38))(803))(502(222(238(520)(628))(747(496(195(669(3)(656(593(846(559)(521))(142(755)(276)))(647(714(281)(761))(401))))(989(349)(381(673)(213))))(458))(308(913)(224(940(425(347)(668(638)(917(27)(243))))(68))(358)))))(797(989(85(372(278)(645))(737(917)(640(428(980)(338(551(172)(20))(609(642)(452))))(637(113(864(299)(366))(796(935)(336)))(944)))))(607(451(525)(739(110)(489(994)(44(563)(821(983)(719))))))(606(855)(804(245(335(886(154)(154))(383))(592(308(590)(837))(231(719)(358))))(749(0(686(862)(307))(921))(402(574(110)(375))(270(102)(888))))))))(803(753(47(746)(936(620(568(701(659)(466))(98))(644(807(375)(8))(309(666)(577))))(23(263)(80))))(67(990(934(731(736(657)(98))(325(260)(8)))(679(355(718)(823))(285)))(207(625)(666(568)(913))))(329(128)(890(266)(642)))))(169(717)(534))))))(61(105(610)(577(26(410(364)(261(866(803)(429(571)(658(906(117)(752))(880))))(262(376)(836(283(189(576)(492))(331(419)(421)))(129(92(256)(684))(337))))))(332(741(627(73)(612(411(275(485)(603))(808))(63(645(972)(263))(737(613)(297)))))(867(21)(903(9(32)(965(496)(197)))(805(60(350)(584))(858(799)(314))))))(940(411(174(807(33)(854(224)(429)))(999(431(853)(91))(429(533)(958))))(161(810(672(896)(158))(592))(290)))(790))))(276(96)(983))))(548(431)(877(810)(437(939(732)(420))(208)))))) +(322(40(406(697)(653(334(763(814(289)(135))(293))(102))(58(294(533(727)(347))(712(881)(953)))(257))))(161(385(597(437)(342(580)(748(296)(560))))(165(522(366(863)(552))(77))(423)))(485(11)(515(970(778)(931(923)(111)))(257(524)(176))))))(480(14(765(513(988(88(236)(387))(349))(810))(570(515(962(395)(197))(888(642)(66)))(718(438(816)(561))(738(884)(490)))))(687(687(230(953(84)(526))(925))(520))(918(543(19(850)(226))(222(388)(723)))(294))))(440(758(576(807(696(75)(573))(791))(187(888(598)(934))(166(545)(284))))(528))(144(666)(895(586)(669(853(875)(600))(495))))))) +(367(144(971(360(303)(884(12(481(748)(36(196(29)(545(549)(407)))(850(529)(425(628)(291)))))(449(386(428)(545(75(267)(378))(924(207)(683))))(994(865(72)(701(333)(46)))(520(229(399)(545))(633(893)(317))))))(367(808)(317(742(273(711(569)(733))(529))(54(164(505)(707))(206(745)(449))))(159)))))(250(722(335(395)(251(297(544(918)(929))(787(405)(648(520)(132))))(834)))(774(534(549(96(738(766)(586))(825))(768(160(984)(680))(931(793)(235))))(506))(94(802(446(93(799)(359))(891(916)(806)))(597(257(188)(940))(951(613)(750))))(687(878(384)(705(235)(812)))(312(195(379)(196))(131))))))(189(829(353(126(193)(852))(625(675)(160(584(174)(616))(612(752)(848)))))(252))(103(288(752(108(38(630)(212))(539(382)(751)))(99(936(569)(271))(262)))(185(844(118(411)(700))(217))(247(734)(6(253)(650)))))(821(829(197(370(390)(887))(386))(480(249(149)(77))(127(213)(385))))(449(370(217(892)(452))(368(65)(677)))(2(865(809)(643))(439))))))))(353(478(506(614(438(646(142(675)(959(422)(194)))(482(353(795)(660))(486(842)(622))))(400(793)(192(393)(689))))(961))(797))(175))(727)))(552(379(762)(386))(184(283(759(522(854(431(7(951(815)(410))(190))(464))(456(527(810(467)(354))(421))(619(423(947)(361))(130))))(753))(771))(144(753(15(322(754(487(589)(211))(961(34)(340)))(567(840)(712(315)(793))))(487))(730))(485(641)(83(407(730(407)(491(642)(473)))(590(125(688)(787))(347(567)(833))))(850)))))(953)))) +(320(876(21(68(322)(964(724(72(115(177)(985))(721(460)(126)))(726(73(505)(83))(32)))(48(713(749(403)(703))(313))(71(180(385)(210))(736(4)(588))))))(435(182(803(311(715(456)(552))(364(142)(273)))(600(261(195)(824))(883(275)(975))))(644(790(410(88)(651))(414))(161(897(315)(899))(646(967)(442)))))(148(559(21(168(932)(659))(889(124)(505)))(168(682(19)(613))(182)))(381(365(692(449)(764))(225(545)(204)))(979(960(380)(449))(360))))))(815(693(658)(793(649(390(14(260)(685))(370))(624))(22(8(492)(429))(715(451(556)(724))(800(294)(455))))))(377(674(221(524)(207))(329(678)(164(928(822)(934))(222(929)(590)))))(354))))(750(338(806)(482(518(943(337)(843(203(804)(965))(294(964)(156))))(791(495)(373(375(460)(228))(334(681)(163)))))(537(233(931)(501(291(249)(436))(802)))(872(649(358(954)(219))(364))(588(301)(310))))))(831(217(471(825(24(856)(286))(613(21)(450(773)(453))))(382))(100))(343(666(6(93(550)(867(622)(999)))(962(267)(454(878)(698))))(549(816(302)(317(619)(115)))(746)))(692(173(897)(632(367(662)(622))(552)))(18(211(301)(436(995)(804)))(281))))))) +(592(880(594(847(551(266)(120(574)(864(677(801)(662))(577(897)(84)))))(724))(738(983)(106(779(592)(784(141)(716(841)(504))))(848))))(434(752)(265(34(352(413(877(529)(879))(163(658)(71)))(138))(969(278(382)(300(671)(602)))(410(181(198)(767))(847))))(580(888)(2)))))(240(977(609(257(46)(855(254(59)(39))(877(646(604)(919))(839(913)(533)))))(496))(84))(786(667(55)(749(47(250)(891))(260(994(277(862)(138))(439(816)(938)))(544(481(140)(950))(374)))))(864(693(988)(676))(334(79)(959(217)(877(190(178)(276))(869(704)(124))))))))) +(294(453(659(644)(625(75(687(802(311(562(830(80)(262))(805(512)(649)))(156))(43))(122(675(428(119(24)(667))(519(704)(777)))(430(185)(56(839)(684))))(814(223(931(634)(490))(987))(719))))(220))(504)))(863(446(366)(319(140)(453)))(1(922(226(744)(260(496)(288(269(639(248)(496))(940(820)(82)))(708(501)(331(341)(558))))))(698(967(864)(386(759(225(868)(953))(381))(727)))(822)))(604(182(667)(411(35(474)(138(205(64)(783))(495)))(995(300(103)(691(101)(524)))(451))))(644(125)(760(429(615(42(754)(595))(571))(526))(486(439)(700))))))))(912(761(407)(337(999)(896(206)(656))))(151(675(400(119(784(634)(800(673)(675(541(889)(282))(883(206)(884)))))(796(372(384(424(622)(397))(279(314)(36)))(24(474)(961(942)(409))))(343(683(17)(931(75)(284)))(328(29(525)(133))(5(236)(222))))))(882(697(466(727)(844(932)(555(87)(430))))(155(424(551(219)(924))(460(117)(245)))(321)))(35(665(249(6(482)(24))(454))(319(690(802)(430))(946(78)(338))))(67(597(787(162)(675))(653))(678)))))(784))(607(636(561)(505(630)(805)))(743(256)(87)))))) +(346(966(18(883(832(888)(759(549(782(505)(828))(571(341)(645)))(886(375(950)(506))(335(875)(949)))))(22))(357(44)(553(510(856)(488))(587(830(736(408)(864))(114))(864(354(635)(747))(667(774)(211)))))))(725(969)(166(970)(702(747(226)(340(830(371)(296))(496)))(139(765(688)(910(574)(298)))(739(830(817)(798))(809(359)(500))))))))(125(428(389(987(169)(738(678(422(414)(999))(941(852)(303)))(108(942(281)(277))(773))))(401(999)(559)))(655))(73(471(450(836)(18(253(124)(399(105)(736)))(532(510(243)(699))(575(444)(66)))))(834(784(2(345)(22(469)(6)))(752))(258(692(398)(311))(507))))(952)))) +(667(914(684(859)(730(220)(948)))(910(271)(191(644)(433))))(519(915(45(762(253)(94(314)(576)))(652(233)(73(916(511(682)(135(648)(428)))(598))(744(555)(28(516)(19(69(838(575)(40))(792(657)(600)))(210)))))))(998(729(308(520(698)(442(905(398(117(361)(809))(161))(119))(975(273(576)(919))(432(65)(95(264)(770))))))(560))(717(337)(761(491)(366(96(662(754(619)(579))(144))(679(597(724)(594))(876(522)(288))))(436(688(711(115)(861))(134(708)(170)))(533(546)(821(870)(672))))))))(745(109)(633(895(860(614)(735(256(112)(764))(796(237(390)(368))(917(834)(250)))))(184))(844(887)(346(789)(717(854(173(45)(943))(150))(941))))))))(791(669(799(419(874)(732(362)(225)))(981))(185(844(185(474(192(741)(722))(650(981(130(196)(307))(377))(774)))(33(848)(507(532)(33(328(407)(276))(153)))))(809))(189(393)(528(180(328(571(791)(36(154)(896)))(212(632)(153)))(167))(594(184(440(766(727)(683))(508(810)(675)))(966(537(188)(977))(888(65)(80))))(60(618(105)(290(312)(996)))(441)))))))(35(516)(883(805(920(240(382(684)(762(87(743)(5))(936(19)(190))))(697(321(41)(929(905)(934)))(776(919(957)(276))(267(900)(350)))))(136(431(822(272)(708(426)(653)))(592(743(778)(378))(758(689)(302))))(125(816(308)(332(18)(515)))(263))))(775))(501)))))) +(261(541(634(380)(941(594(171(633)(277(387(550)(52))(443(391)(261))))(510(608)(269)))(349)))(835(610(279(127(977(650(378)(442))(75(496)(891)))(298(95)(268(78)(687))))(403(883(529(346)(934))(497(487)(782)))(119(67)(868))))(890(783(160(620)(450(284)(239)))(16(636(194)(139))(207(535)(599))))(699(188)(901(570(774)(770))(554(144)(555))))))(457)))(701(605(235)(856(681(935(763(941(904)(584))(909))(68(409(832)(111))(823(860)(779))))(516))(83(370(831(471(906)(294))(788(673)(824)))(662(772(59)(624))(825(641)(135))))(762(131(644(280)(83))(603(328)(626)))(153(719(667)(451))(770(422)(245)))))))(984(912)(367(540(428(262(926)(65(505)(442)))(955(833(52)(62))(88(720)(865))))(718(442(65(310)(255))(418))(765(179(745)(43))(329(2)(667)))))(118(780(145(38(577)(460))(476))(281(606(957)(833))(984(262)(581))))(492(40(797(343)(98))(146(513)(642)))(577(730(740)(205))(725(997)(546))))))))) +(410(55(51(490(832)(240(429(150)(916(745(204(691)(932))(548(499)(124)))(155)))(90(638(720)(837(827)(600(792)(321))))(603))))(362))(540(88)(459(935(926)(791(128(868(480(402)(255))(51))(478(753(309)(195))(109)))(423(976(621(769)(842))(94))(875(230(42)(772))(483(706)(492))))))(48))))(634(200(825(804(990(978(896)(979(258)(380(380)(498))))(485(54(314)(410))(470)))(686(381(689)(608(937)(192(134)(591))))(952(363(936(169)(486))(771(251)(16)))(122(849(49)(931))(892(996)(97))))))(749(55(497(839)(774(27(648)(343))(46(53)(730))))(711))(569)))(20(358(833(164(857(612(578)(598))(523(440)(769)))(363))(398(111(719(394)(271))(703(912)(463)))(518)))(215(108(467(567(744)(829))(727(77)(723)))(788(57(741)(186))(226(774)(484))))(946(361)(966(29)(29(589)(534))))))(586(238(482(422(894)(261))(315(435(155)(578))(221(864)(622))))(429(398)(255(468(36)(989))(988(560)(926)))))(534))))(729(258(693(145(707(319(674(921)(194))(944(407)(268)))(837(131)(243(616)(881))))(107(899)(348(596(356)(108))(81(131)(66)))))(683))(996))(111(846)(582))))) +(99(760(785(571(577)(217(137(82)(937(453(48(930(388)(227(302)(687)))(848(99(689)(298))(253(856)(179))))(573(644)(695(244)(892))))(838(618(932(807)(896))(107(379)(228)))(367(692)(359(954(973)(794))(890))))))(329(159(633)(654(342(832(930(670)(194))(743))(641(418)(787)))(170(866(94(307)(173))(924(592)(277)))(82(22(460)(239))(333(965)(726))))))(921(995(895(836(212(176)(801))(637))(206(427(476)(738))(330(984)(470))))(647(837(313(892)(182))(524(176)(613)))(265(258(549)(482))(962(846)(519)))))(145(241(290(130(857)(538))(871(325)(7)))(680(140(205)(38))(97(381)(898))))(460(352)(601)))))))(277(857)(137(476(325(243(156(228(916(764)(602))(968(393)(220)))(805))(362))(875(947)(272(350(984(815)(762))(971(593)(691)))(272))))(799(595)(839)))(422))))(665(894(461)(544(880(888(719)(631(215)(829(714(488(129)(941))(628(169)(722)))(830))))(601(934(958(479)(614))(570(988(223)(503(104)(479)))(522)))(575(580(324(873)(158(81)(855)))(549))(701(113(767(545)(454))(164(282)(49)))(807)))))(238)))(91)))(115(46(641)(825(196(418(307(173(550)(152))(400(48(954(18)(965(485)(576)))(271(355(334)(549))(177)))(335(435)(472(94(932)(155))(215(523)(230))))))(473))(885))(635(365(341(835)(774(707(499)(144(757(691)(704))(534(106)(815))))(912(59(101)(301))(636(144(882)(103))(385(10)(687))))))(868))(516(395(321(472(104)(716(639(4)(497))(993)))(838(114)(131(217(588)(944))(780(889)(449)))))(471(927(76(505(729)(58))(929))(749(748(566)(729))(647(758)(285))))(300)))(733)))))(877(978(308(818(493(884(803(97)(62(395)(940)))(312))(461(526(77(520(48)(590))(906))(456(365(901)(264))(65)))(968)))(273(659(782(281(152(65)(953))(944(772)(75)))(976(55(925)(508))(526)))(827(134(673(309)(518))(696(629)(905)))(251)))(307)))(263))(471(447)(5(97(308)(729))(282))))(966(890)(86(977)(32)))))) +(252(556(259(58)(553))(252(553)(232(286(10(126)(654))(949(515(557)(242))(697(346)(638))))(430(704(806(516)(222))(70))(910(287)(865(848)(419)))))))(687(3(95(405)(888))(14(14(223(573)(551(689)(5)))(542(702)(22(211)(237))))(723)))(262(266(274(700(62)(493(640)(496)))(528(397(40)(245))(954)))(87(474)(427(813(916)(650))(916(841)(575)))))(750)))) +(734(442(130(617(578(626)(752(449(907)(888))(610(118)(316))))(538(231(597)(897(537)(299)))(731(776)(41(672)(511)))))(13))(398(303(972(266)(556(660(351)(638))(458)))(767(887)(353(133(152)(801))(997(856)(957)))))(6(427)(351(902(788)(27(105)(580)))(908(953(689)(465))(312))))))(517(963(20(792(287(566(423)(378))(73(727)(642)))(98(685(171)(69))(923(661)(989))))(436(355)(272)))(744))(91(667(164)(665))(473(70(610(431(127)(902))(84(177)(801)))(115(877(472)(927))(187)))(891(48(694(322)(821))(715))(216(509(513)(17))(896(619)(122)))))))) +(655(558(864(315(611(210)(547))(76(24)(409)))(596))(60(797(274(702(902)(307(800(642)(275))(494(625)(30))))(726))(949))(542)))(564(203(155(11(306)(992))(946(509(813)(645))(918(350(866)(815(357)(867)))(234(443(452)(253))(589(587)(407))))))(148(82(829)(878(61(110)(241))(763)))(198)))(485(111(829)(706(36(448(25)(781(963)(304)))(643(514(128)(709))(791(500)(161))))(460(202(250)(96(206)(405)))(736(65)(553(868)(296))))))(447)))) +(728(760(302(553(753(145)(709(773(337(932)(761))(456(991(317)(912(929(589)(132))(136(893)(192))))(511)))(935(817)(493(546(950)(37(841(811)(936))(355)))(356)))))(849))(991(398(963(324(547(382)(655(704(696(471)(166))(483(795)(146)))(517(462)(665(324)(880)))))(456))(628))(659(7)(669(347(921(653)(660(509(183)(903))(55(697)(251))))(575(318)(830)))(332))))(372(932(994(810(431)(683(137(700)(770(147)(52)))(946)))(336(580(43(954(517)(29))(568))(318(185(677)(107))(586(318)(926))))(108(412(802(33)(128))(173))(834))))(764))(603(60(877(248(613(571(833)(126))(357(290)(333)))(617))(671(384(12(39)(452))(752(137)(561)))(181(288(684)(929))(730(693)(961)))))(866(22(883(312(867)(159))(114))(901(37(956)(619))(190(436)(152))))(504(620)(538(686)(417(31)(758))))))(864)))))(891(369(935(818(949(141(258)(82(98)(99(385)(157(860)(651)))))(997(677(205(959(35)(78))(145(919)(470)))(121))(465)))(946(26(815)(607(298(971(615)(851))(685(892)(541)))(827(956(253)(784))(833(657)(389)))))(352(966(314(53(346)(468))(141(957)(208)))(170(32(873)(985))(511)))(94))))(780(353(609(87(365)(421(103(836)(15))(894(665)(214))))(171(201(441)(682(857)(312)))(259(291)(668(176)(592)))))(269(244(927(672(642)(333))(32))(877))(562(325(62)(875(68)(796)))(530(933)(259(756)(690))))))(595(895(456(543(919(226)(578))(890(158)(379)))(117))(907))(308(202(34(150(807)(241))(590(100)(877)))(980(137)(955(826)(732))))(106(650(929(326)(631))(780))(940))))))(19(1)(998(893(516(140(24(28(900)(149))(926(387)(913)))(484))(106))(789))(689(953)(679)))))(141(718)(500(603(801)(285))(781)))))(376(250(810)(68))(659(99(184)(776(822(553(548(345(181)(571(169(224)(644))(790(575)(939))))(62))(598))(718(283(711(929(678)(519))(628))(762(146(421)(514(289)(602)))(347(135(126)(683))(764(653)(588)))))(804(486(872(523(70)(247))(693))(230(33)(767(629)(956))))(430(48)(13)))))(59(717)(249(211(94(581(26)(424(568)(890)))(162(980(738)(64))(892(563)(879))))(10(623(450(87)(53))(836(981)(705)))(375(658(481)(49))(887))))(798)))))(617(178(728(646)(543(454(95(131)(377(152(406)(54))(654(155)(835))))(787(731(61)(785(354)(215)))(100(10)(692))))(399(569(790(330(351)(218))(868))(681(622)(66)))(443(993(524)(876(741)(557)))(59)))))(388(680(988)(167))(255(761(181(195(250)(903(457)(290)))(374))(352(194(911(972)(331))(2(746)(139)))(914(750(312)(991))(594(744)(773)))))(380))))(730(867)(241(745(933(904(916)(616(398(0)(95))(10(158)(642))))(816))(120(267(931)(466(821(528)(222))(567(376)(668))))(200)))(811(285(1(894)(719(972(379)(650))(422(994)(10))))(239))(120(259)(748(61(521(426)(755))(344(181)(600)))(640)))))))))) +(502(740(856(332(132(113)(964(502(925)(22))(195(997)(705))))(771))(385))(107(790(771(677)(639))(663))(861)))(728(986(362(559(524(720)(458(853)(589)))(450))(21))(993(230(581)(157(206(957)(270))(190(686)(205))))(327(374(769(571)(776))(143))(754(192(215)(393))(827(307)(951))))))(159(731)(924)))) +(79(999(151(586)(56))(631(606)(400(276(881)(748))(952(641(701)(249(281(821)(661))(554)))(881)))))(829(963(946(373)(604(377(805)(372))(828(243(665)(373(342(72)(998))(979(68)(247))))(938(98(802(105)(597))(570))(550)))))(667(468(442)(626(444)(580(337)(553))))(830(597)(151))))(898(58(404(235(325(888(251(574)(961))(687))(28(845(313)(977))(297(638)(240))))(868))(712(410(699)(447))(577(462(786)(870))(423))))(206(437(129(905(711(407)(298))(14))(635(201)(627(226)(135))))(781(646(384)(263))(590(454(77)(235))(145))))(996)))(6)))) +(896(250(11(658(389(504)(159(576(920)(836))(608)))(617(31(997(648)(647))(392(859)(846)))(855(513)(326))))(321(715(446)(929(908)(839(815)(337))))(590(338)(743(7)(446(28)(385))))))(439(838(14(736(256(177)(398))(866(653)(23)))(395))(953))(51)))(229(970(93(380)(999(251(339)(711(915)(300)))(428(472)(810))))(379(392(551)(86(700(593)(546))(788(897)(477))))(385)))(253(98(648)(717(642(196(749)(213))(736(395)(250)))(814(44(223)(990))(249(894)(338)))))(516)))) +(29(594(488(63)(746))(997(110(76(330)(579))(730(965(779(201(95)(14))(80(551)(760)))(577(329)(780)))(616)))(505(784(610(481)(452))(472(533(782)(961))(777)))(623(301(677)(803))(706(261(703)(718))(303(503)(556(618)(747))))))))(612(840(65(588(991(385)(203))(848))(571(301(224(260(518)(321))(222(237)(881)))(763(41(927)(59))(826(16)(249))))(816(209(912(74)(57))(18(343)(378)))(399(694(784)(523))(525(825)(903))))))(901))(729(749(4(329(515(382(80)(183))(25))(495(884(167)(284))(413(151)(864))))(477(603(144)(188(631)(341)))(790(897(334)(473))(1(163)(818)))))(500(299(749(922(601)(775))(751(832)(830)))(405(83)(222)))(33(167(664(340)(920))(163(824)(126)))(581(709)(861(373)(559))))))(568(94(697(229(785(497)(393))(214))(704))(121(969(28(444)(583))(870(254)(618)))(685(159)(284))))(194(22)(26(996(70(122)(769))(987))(464(598(601)(319))(192(912)(166))))))))) +(662(884(946(656(795(367)(60(626(56(704(241(740)(45))(465(122)(207)))(260(708(589)(916))(245)))(593(465(322(753)(630))(448(285)(451)))(481(321(78)(746))(413(145)(477)))))(602(942(217(176(456)(666))(2(503)(253)))(670))(948(510)(587(432(335)(533))(451(743)(224)))))))(376))(40))(868(453(680(795(788(284)(422(1(109)(805(750)(298)))(427)))(674(350(364(613(881)(33))(629))(812(891(135)(886))(263(625)(482))))(740(482)(520(591(821)(224))(774(670)(78))))))(379(101(743(867(548)(429(315)(984)))(267))(767))(827(724(212(516)(8))(229(980)(260(239)(229))))(383(883)(888(12(479)(527))(666))))))(751))(716(573(997(926)(67))(554(461)(3(12(974(840(997)(788))(907))(363))(604(787)(435)))))(550(958(475(968(866)(704(702(357)(59))(313)))(51(355)(119(352(669)(423))(673(389)(56)))))(255(484(316(545(468)(112))(501(649)(513)))(83(33)(542)))(754(343)(950(390)(393(659)(163))))))(736)))))(771(765(521(11)(16(437(352(570(461(608(433)(476))(907(805)(167)))(674))(453))(959(389(861(22)(685(23)(76)))(807(955)(438(32)(133))))(401)))(229(919(152(942)(673(393(391)(330))(213)))(274(408(447(491)(581))(324(26)(526)))(425(88(315)(420))(427))))(838(613(728(584(122)(435))(693(621)(393)))(809))(750(309)(332(772(922)(127))(436(238)(229))))))))(50(350)(312(609)(925(389(781(451(935(311)(368))(377(896)(777)))(811(641)(66)))(437(828)(420(48)(42(853)(938)))))(337(787)(288(487(313)(544))(68(394)(685))))))))(817(496(397(594(930)(119(720(49(785(418)(298))(826(508)(605)))(912(444(16)(411))(227)))(304)))(970))(14(176)(959)))(145(81)(161(895(378)(5(58(839(10)(508(542)(227)))(85))(261)))(616(861)(958(245(934(570(895)(102))(721(125)(311)))(631(544(51)(699))(191(290)(948))))(765(287(411)(202(241)(876)))(62(104)(238(654)(993))))))))))) +(801(628(263(35(303(401(417(942(141)(222))(426(527)(124)))(836(913(853)(773))(688(908)(220))))(430))(306(572(505)(183(888)(880)))(208(92(154)(137(0)(600)))(736(206(888)(450))(326(789)(114))))))(735))(304(942(393(892(984)(507(588(516)(99))(734(784)(999))))(925(446(612(752)(353))(339(730)(676)))(89(231)(685(461)(609)))))(828(268)(76(686(557(499)(177))(77(917)(18)))(266(24(934)(910))(837(226)(895))))))(948(666)(748(198(100)(994(592(637)(434))(253(858)(804))))(433(532(357(83)(145))(635(371)(995)))(144))))))(137(597(929(62(422(717(816)(301(638)(25)))(123))(132))(404))(843))(471(146)(536(896(822)(959(769(172)(284))(853)))(156))))) +(704(294(634(743(365(112(182)(488))(675(586)(822(968)(278))))(809(481(679(389)(765(73(810(782)(989))(286(445)(390)))(51(327(509)(350))(208))))(854(85(760(375(915)(954))(626(168)(243)))(61(83(786)(785))(709)))(73)))(133)))(178))(318(177(501)(316(621(364(447(980)(24))(546))(383(799(854(790(130)(963))(775(657)(30)))(30(222)(614(789)(874))))(630)))(371(710)(792(144(883(273(497)(162))(257(992)(463)))(767(614(324)(371))(566(43)(219))))(992(649(282(900)(797))(844))(462(53)(617(527)(139))))))))(698(272)(177))))(304(197(683(442(533(947(664)(253(212(679(858)(74))(158))(269)))(862(678(177(631(90)(180))(956(748)(755)))(322(373)(451(838)(371))))(792(851(715(302)(179))(609(732)(161)))(213(524(563)(746))(710)))))(264(106(251)(130))(774(285(24)(55(685)(618(783)(621))))(40(329)(244)))))(661(219(615)(808(314)(899(749(933(595)(432))(855(799)(882)))(706(231)(345(614)(238))))))(520)))(986))(997(730)(806(911(495)(292(255(29(379)(243))(473(319(740(719)(49))(697(820)(419)))(173(526)(251(513)(817)))))(13(284(83(602(470)(421))(752(432)(0)))(276(495(536)(675))(150(124)(534))))(510(857(502(721)(476))(649))(922(784)(440(721)(991)))))))(354(938(736(750(196(804(315)(124))(203(502)(810)))(838(416)(346)))(627(401(618(717)(468))(213(703)(163)))(637(101)(428(622)(153)))))(284(972(11(917(902)(317))(561(50)(289)))(597(663(742)(687))(772(688)(32))))(563(618)(38(9(236)(225))(905)))))(22)))))) +(503(796(915(843(514)(392(618(218)(289(733(709)(229))(408)))(206(25(93(680)(891))(391(268)(964)))(66))))(265(889)(157)))(808(302)(727)))(824(403(31(16(314)(465(474(604(6)(414))(294(246)(728)))(718(326)(51))))(832(910(174)(181(38(750)(199))(762(760)(980))))(864(229)(333(493)(391)))))(960(798)(336(437(587(299(294)(41))(349(227)(906)))(371(517(965)(226))(449(500)(51))))(807))))(544(194)(642(620(325(743(829(151)(700))(802(619)(173)))(345(689)(572(540)(28))))(290(675(515(309)(124))(330(847)(385)))(626)))(730(826)(413(797(807)(170(185)(885)))(217(851)(531(548)(493))))))))) +(840(452(552(6(903(632(381)(113(399)(353)))(180(504(121)(825))(605(57)(407))))(840(651)(1(387(358)(755))(520(647)(962)))))(837))(356(759(533(731(160(228)(548))(522(225)(461)))(379(156(667)(777))(438(200)(572))))(211(19(184)(863(928)(237)))(326(221(829)(867))(765(709)(743)))))(446)))(994(332(763(683)(957(821)(313)))(223(362(645(270)(921(232)(281)))(926))(133)))(957(736(851(236(848)(741(706)(90)))(378))(405(989(696)(884(995)(991)))(179(805(420)(464))(49(627)(88)))))(362)))) +(179(734(868(218(212(776(704(477)(639))(237(325)(127)))(821))(449(449(502)(362(680)(613)))(998)))(170))(648(331(736(47(325)(215))(375(134(607)(384))(273)))(517(570(665(93)(752))(826(230)(480)))(814(952(960)(644))(632(139)(675)))))(797(918(761(658(273)(628))(993(585)(874)))(307))(862(680)(138(596)(705))))))(904(144(251(620(467(185(431)(795))(668(398)(398)))(134(929(539)(451))(236(724)(555))))(989(824(562(471)(601))(101(210)(14)))(444(301)(755(127)(384)))))(684(524(676(95(460)(605))(323(717)(269)))(99(243(31)(875))(634)))(977(738(92(828)(581))(478))(340))))(534(584(838(641(516(405)(334))(220))(423(913(140)(593))(271(269)(499))))(594(534(646(475)(358))(252(94)(385)))(697(771)(542(353)(108)))))(744(867(396(225(788)(433))(933(406)(416)))(16(933)(52(78)(290))))(327))))) +(568(749(107(784(197(580(979(980(336)(392))(597(80(101)(315(188)(179)))(941(482)(821(112)(546)))))(745(316(209)(308(582(665)(745))(253(177)(756))))(797(487(403(234)(640))(190))(296))))(632))(537(879(442(236)(58(303(947(684)(262))(704(31)(990)))(543)))(269(276)(632(578(127(319)(409))(113(311)(284)))(964(572(811)(170))(573(932)(446))))))(305(789(70(96(401(592)(151))(76(832)(759)))(352(663(7)(144))(768)))(14(34(457(618)(808))(75(956)(915)))(178(370(189)(409))(938(947)(920)))))(258))))(642(876)(902(735)(710(761(318(236(504(974)(113))(222(96)(616)))(982(577(761)(920))(940(420)(725))))(622(863(578)(291(806)(307)))(527(711)(978(860)(220)))))(191(228(758(745(221)(774))(57(85)(400)))(40))(509(979(28(93)(60))(868))(26)))))))(650(237)(47(502(956(563(630)(48))(30(764(652(327)(282(412)(817)))(456(96(400)(395))(685)))(608(732)(96(659(268)(696))(329)))))(499))(121(392(495(681(759(330(214)(297))(42(826)(18)))(462(939(25)(442))(13(879)(859))))(640(751)(442(855(234)(468))(512(474)(408)))))(51(282)(68)))(730)))))(822(176(180)(691(521(676(830)(81))(897(889(898(10(691(236)(482))(468(304)(218)))(517))(725))(87)))(833(84(456(79(656(101)(293(433)(880)))(0(91(915)(280))(118)))(213(696(816(385)(582))(955(460)(622)))(298(667(868)(590))(859(984)(301)))))(932(621(69(543(89)(959))(678))(932(995)(367(585)(912))))(243(768)(970(890(397)(50))(175(463)(858))))))(870(987(902)(793(245(598)(181(556)(741)))(794(566(606)(23))(144(974)(113)))))(616)))))(138(294)(817(682(23(686)(621(57(469(0(165)(458))(939))(744))(679(359)(520))))(951(20)(720(919(382(346(227)(563))(581(75)(737)))(526(492)(988(338)(481))))(173(801(534(421)(997))(908(513)(767)))(85(837(577)(754))(705(300)(246)))))))(622(93)(794)))))) +(266(36(732(651(967(999(294(444)(272(901(19)(737))(594(832(563)(42(679)(909)))(148(118(773)(289))(526)))))(414(771)(927(577)(635(596(874)(466(507)(186)))(346(474(418)(696))(971))))))(260(379)(173(984(25(366(498(711)(978))(364(704)(854)))(762(23(32)(186))(917(149)(719))))(72(512(995(492)(156))(14(495)(633)))(998)))(605))))(495(699(164(979(526(591(250(153)(373))(546))(846))(426(550(788)(463(224)(467)))(969(398(940)(166))(613))))(36(335)(595)))(587(490(34(161(73(888)(542))(470))(130(181(193)(24))(161(893)(422))))(752(518(71)(23(578)(863)))(533)))(122)))(296(278)(615(942(85)(441(16)(697(318(947)(602))(831(979)(926)))))(261(121)(291))))))(819(241(391(454)(879(5)(324(237(914(760)(805(885)(486)))(980(85(457)(481))(938)))(48(765(928)(240(394)(904)))(266(783(956)(362))(685(376)(530)))))))(683(640(334(300(772(941(271)(847))(415(314)(412)))(263))(843(180)(911)))(540))(883(879)(819(430(396(526)(335))(846(605)(538(620)(83))))(713)))))(33(614(141(577)(590(375(538)(974(784(190)(123))(995(274)(790))))(650(631(541(891)(107))(8(885)(327)))(539(508(933)(962))(217(890)(312))))))(375(520)(6)))(871(99(711(314)(153))(296(390(479(924(23)(284))(148(766)(244)))(1(366(838)(291))(854(911)(781))))(848(436(802(268)(956))(960))(330(145)(443(353)(67))))))(586)))))(74(417)(74(376(879)(784(271(992(843(220(184(444)(568))(36))(741))(557))(150(125(825)(281(40(20)(389))(913)))(46)))(834)))(405(321(937(729)(288))(445(388)(273(256(13(792(38)(649))(661(257)(329)))(174(899(701)(264))(47(350)(452))))(251))))(534)))))(224(431(869(877(17)(95(83)(695)))(718))(276(647(181(41(120(209(119(472(305)(496))(843))(483(171(657)(179))(448)))(390))(352(671(628(805)(454(927)(952)))(210))(262(800(565(702)(260))(664(510)(486)))(317(364)(34(303)(396))))))(622(778)(546)))(279(356(613(947(910(626(806)(708))(59(769)(630)))(984))(996(1(739(449)(386))(986(917)(915)))(204(680(921)(507))(868(468)(661)))))(576(965(935(727)(26(447)(89)))(321(976)(119)))(519(877(779(687)(322))(25(993)(430)))(356(903(109)(181))(189(220)(490))))))(78(404(644(271(682(417)(470))(405(327)(430)))(265))(444))(123))))(622(691(292(881(549(561)(496(198)(654)))(744))(541(7(580)(671(313)(426(679)(687))))(735(399(351(321)(671))(82))(487(690(811)(847))(377(638)(860))))))(817))(319))))(766(841)(499)))) +(626(134(15(117(906(278(110(566(407)(722))(589(365)(624)))(369(320(87)(483))(48(751)(540))))(950))(838(545(505(280(807)(853))(205(216)(880)))(676(457)(302(892)(608))))(49(195(357(477)(32))(999(846)(699)))(257))))(286(981(205(616(990)(21(578)(527)))(545(297(93)(389))(811(516)(875))))(257(880(741(736)(861))(236(64)(430)))(823(767(687)(308))(9(748)(879)))))(487)))(297(102(157(10)(105(433(254)(90(304)(472)))(687(456)(72(32)(180)))))(378(25(328(109(616)(959))(443))(918(732(581)(984))(66)))(517(655)(110))))(977(16(516(631(217(501)(201))(976))(985(866(571)(698))(176(351)(764))))(336))(93(759)(623)))))(718(274(97)(88(626)(107)))(165(127(78)(167(282(76(584)(294))(906(993(55)(526))(840)))(182(671)(753(535)(946(22)(895))))))(340(190(669(411(464(848)(239))(647(706)(187)))(772(41(64)(756))(849(239)(747))))(840))(224(614(36(233)(326(721)(879)))(344(62(284)(203))(614)))(504(247)(386(995)(110(167)(203))))))))) +(594(992(560(64(251(42(7)(36(23(104)(603))(433)))(369(715)(178(37(261)(975))(837))))(286(953(606(312(5)(284))(957(26)(138)))(808))(321)))(759(516(658)(464(898)(363)))(22(23(446(268)(784(31)(954)))(184(830(267)(797))(857(194)(426))))(670(474)(140(636(726)(787))(333))))))(924(299)(704(447)(316(215)(866(642(828(382)(151))(562(66)(570)))(418(719)(688(575)(748))))))))(348(533(241)(860))(307(908)(199(876(317)(465(426(630(378)(349))(528(21)(912)))(599(267(847)(809))(76(10)(98)))))(441(913(175(466(268)(953))(790))(157(862(974)(809))(925(888)(863))))(504(746)(500(982)(350)))))))) +(642(19(981(379)(316(85(903(548(115(551)(876))(664))(352(794(137)(88))(772(668)(719))))(63(691(694(741)(9))(149(573)(921)))(258)))(573)))(283(776)(59(392)(955(240(754(601(272)(194))(822(217)(944)))(998(646)(219)))(342)))))(18(532(86(215(289)(413(226(484(569)(835))(922))(589(728)(0))))(480))(263))(511(11)(32(406(519)(788(221(22(940)(577))(541))(772(247(721)(991))(785(600)(751)))))(526))))) +(178(616(609(309)(215(292)(626)))(359(579(620(220(904)(225(461(859(351(80)(187))(535(511)(72)))(568(118(733)(817))(334(284)(875))))(283(862(486(210)(510))(877(137)(991)))(652(382(576)(674))(0)))))(185(665(824)(819(939(803)(937(650)(400)))(510)))(179(790(394)(622(174(417)(421))(774(689)(888))))(434(38(138)(771(360)(641)))(893(798(539)(613))(298(866)(381)))))))(559(769(524(529)(290))(57(808(141)(365(780(563)(279))(543(504)(11))))(751(904(367)(20(380)(620)))(743(705)(347)))))(886(620(908(473)(936))(170(924(569)(243(447)(569)))(161)))(575))))(933)))(942(519(24(641(38)(687(672(43(811(859(595)(531))(716(930)(414)))(622(864(164)(754))(174(308)(767))))(533(626)(429)))(829(688(634(716(391)(950))(944))(798(63(912)(955))(558(155)(26))))(878(952)(973(409)(885))))))(691))(287(836(912)(492))(627(819)(41(738(808(777(696(203)(801))(18(126)(882)))(583(433(695)(57))(430(905)(841))))(882(301)(829(425(909)(710))(903(86)(454)))))(661)))))(378(575(329(634(341(401(108(409)(918(314)(866)))(40(436)(841)))(940(409)(832)))(741(817(481)(563(464(210)(163))(19(651)(653))))(212)))(484))(396(701(600(967(812(858)(762))(753))(13(834(386(632)(272))(523))(695(400(316)(316))(748(845)(442)))))(240(7(910(636(942)(862))(582(110)(696)))(523(951)(725(782)(751))))(12(971)(390(11(650)(996))(834)))))(665(363(322(246(666)(544(356)(317)))(233(122)(245(176)(101))))(820))(809(626(933(0(570)(762))(892(180)(72)))(294(28(863)(135))(305(552)(965))))(465)))))(777(810(172(436)(847(828(385(838(836)(379))(987(692)(580)))(149))(66)))(362(474(436(581)(549))(360(347(199)(956(898)(53)))(700(299)(830(926)(525)))))(441(713)(946))))(317(42(378)(226(789(806(451(198)(859))(570(233)(468)))(508))(596(114(95)(233))(865(454)(444(252)(674))))))(940)))))) +(921(84(278(331(133)(942))(173(139(406(314(510)(656))(963(307)(503)))(370))(815(143(4)(168(123)(613)))(62))))(203(857(641(309(868(773)(697))(475(183)(97)))(316(767(256)(959))(319(475)(27))))(192(49(733(155)(755))(142(568)(654)))(841)))(572)))(914(311(813)(148))(55(545(880(480(257)(567(94)(150)))(779))(502))(731(988(21(644(298)(105))(164))(179))(676))))) +(444(439(690(270(836(864(967)(763(222)(329)))(213))(797))(257(709(12(937(555)(544))(442(236)(649)))(264(878(843)(689))(869)))(911)))(622(313(737(337(254(264)(645))(561(40)(891)))(966(742)(892(967)(14))))(979))(772(646(650(451(368)(983))(479))(25))(907(837(368(326)(446))(715))(962)))))(639(589(860)(180(72)(680(231)(120(445(607)(613))(121(840)(90))))))(160(984(669(288(898)(191))(989(572)(889(232)(867))))(301(969)(623(541(815)(624))(252(316)(879)))))(560(702(38(97(980)(394))(958))(204(583(659)(402))(39(752)(412))))(416(756(252(49)(837))(954(640)(605)))(731)))))) +(193(527(973(446(167)(603(268)(451(599(412(24(368)(885))(568))(215(647(523(393(105)(404))(354(539)(911)))(378(752(46)(581))(827)))(942(504)(154(802)(635(464)(350))))))(170(830(269)(312(857(76)(734(378)(158)))(256)))(580)))))(267(14(264(906(760(207(897(421(335)(523))(633(687)(481)))(966))(485))(918(826(914(343(962)(503))(47))(550(228)(243(944)(993))))(50(407)(608(433)(903)))))(413(651(939)(48(385(128)(583))(218(188)(900))))(920(960(589(434(464)(281))(573(542)(672)))(807(62(280)(129))(770)))(361(645)(962(403)(562(193)(894)))))))(990))(529(305(560)(623(935(36)(711))(221(322(969)(161(405(534)(603))(869(966)(249))))(185))))(497(410(689)(642))(316(749)(534(149(306)(678(935(278)(890))(155(923)(724))))(869(210)(734(511(637)(147))(220(606)(871))))))))))(866(379(198(422)(589(197(156)(569))(770(689(474(600(312(382)(477))(534))(155(84(313)(343))(890(445)(313))))(808))(879))))(435))(613(579)(120(432(14(714)(491))(868))(861(844)(93))))))(535(657(983(508(158(630)(970))(455(100)(168(676(890)(353(986(401(658)(935))(213(672)(265)))(201(472(553)(536))(476(397)(793)))))(368))))(277(418)(354(897)(779(267(762(700)(305(758(183)(611))(152(567)(653))))(680))(304(395(622(26)(425(792)(148)))(307(50(378)(212))(582)))(508))))))(993))(210(681(23(536)(811(445(152(671(22(896(856)(73))(594(538)(80)))(948(36)(842(220)(411))))(251(135(395)(86(201)(137)))(107(665(935)(305))(445(174)(915)))))(611(145(406)(713(181(558)(258))(339(736)(794))))(783(54(427(674)(640))(404))(776))))(670(422)(935(422(331(433)(24(654)(549)))(394))(669(754(656)(801(512)(248)))(666(904)(299)))))))(733(48(986(260(205)(362(950(590(896)(901))(773(142)(382)))(517(755)(766(795)(340)))))(137(690)(367(955)(680))))(868))(869(18)(666(342(804(806(339)(292))(482(232(420)(276))(764(949)(455))))(28(43(374(142)(542))(202(158)(62)))(570(811(330)(105))(304))))(375(209(464(737(669)(457))(311))(505(514)(586)))(322(338)(535(843(157)(824))(801(342)(497)))))))))(485(346)(882(801)(250(638(316(4(849)(288(241)(757)))(169))(572(308(502(254)(558(744)(699)))(972))(55)))(738(154(89(736)(997))(983(884)(448(498(885)(454))(840(187)(49)))))(276(791)(107(112(550(24)(109))(889))(199(888)(679(917)(585)))))))))))) +(150(648(364(555(790(992(428(668(860)(521))(80(317)(177)))(143(871(753)(617))(760)))(707(782(739(605)(358))(213))(293)))(888))(357(79)(486(546(774(596(984)(73))(655(494)(0)))(232))(845(626(85)(673(526)(423)))(234)))))(677(471)(157(898(135(764)(913))(684(303)(711(687)(94(465)(755)))))(416(585)(215(156)(196(964(54)(268))(227(901)(815))))))))(667(295(574(535(609(969(843(901)(978))(85(551)(696)))(467(971(263)(585))(910)))(958(64(514(956)(91))(967))(343(820(388)(733))(672(811)(411)))))(594(827(705(658(740)(415))(220(438)(821)))(372))(380)))(995(950(887(468(794)(644(81)(393)))(743(918(64)(297))(615(737)(662))))(714(646(160(22)(477))(238(595)(934)))(655(419(995)(494))(275))))(19(934(287(350(995)(526))(815(287)(700)))(657))(217(258(548(492)(234))(0(609)(129)))(623(910(407)(90))(819))))))(448(210(802)(488))(763(93(194(276(440)(39(349)(137)))(683(561)(286(765)(324))))(968(196(849(282)(451))(803(247)(949)))(201(163(554)(469))(641))))(92(687(281)(193(780)(745(44)(376))))(894(337)(547(632(400)(108))(132(564)(903))))))))) +(920(126(443(750)(378(337)(148(226)(226(407(233(152)(557))(819))(773(248(714)(832(63(210)(589))(326)))(755(739)(391(658(225)(996))(54))))))))(225(662)(943)))(241(922(95)(547(359)(326(390)(577(291(138(16(235(155)(230))(536(81)(825)))(157))(285(827(345)(560(492)(887)))(788(286(922)(519))(433(990)(977)))))(181(540(810)(899(539(9)(152))(996)))(59))))))(346(949(18(872(207(714(633(564(809)(501))(505(529)(861)))(385(406(966)(776))(669)))(601(305)(422(119(459)(789))(441(219)(293)))))(637(795)(898(96(264(220)(681))(712))(793(198(96)(100))(204(566)(668))))))(969(880(853(858(101(44)(884))(840(265)(513)))(613(841)(950(672)(254))))(972(112)(793(16(834)(984))(625(837)(139)))))(140(215)(497(868)(530(898(775)(679))(738(73)(963)))))))(159))(98)))) +(231(604(477(11(561)(237(719(224(373(84(982(340)(583))(667(433(369)(560))(235(363)(315))))(60(213(794(663)(349))(908))(483)))(586(693)(607(430)(918(800)(84(326)(310))))))(348(328)(56(59(630(828(654)(590))(66(643)(368)))(261(583(671)(999))(155(637)(482))))(87))))(824(772(472(616(71(50(753)(496))(86))(545(446(543)(639))(979(82)(272))))(884(554)(672(48(634)(128))(356(245)(564)))))(792(769(461(199)(848(82)(961)))(446))(100(830(269(451)(304))(507(966)(62)))(665(323(168)(986))(65)))))(157))))(138))(738(619)(573(543)(643(991)(565(619(81(406(655(412(923)(626))(216))(806(585(702)(793))(152(541)(302))))(51(287)(122(861)(753(806)(682)))))(490(311(724(104(311)(240))(922))(933))(847(252)(240(294(418)(495))(659)))))(915))))))(416(822(299)(343))(665(987)(599(13(713(708(986(172(697(150(510)(255))(398(176)(315)))(12(187(483)(932))(943(831)(587))))(637(361(782(613)(399))(150(234)(753)))(162(133(155)(114))(943(579)(880)))))(619))(791))(504(554(202)(118(458(940(410(597)(464))(136(640)(463)))(686))(145(360)(666))))(599(705)(912(560)(896)))))(158(107(467(649(894(872)(402(190(732)(553))(924)))(243(686(865(679)(486))(237(101)(100)))(742(607(540)(258))(353))))(829(521(372(915)(933(613)(425)))(146))(27)))(482(543)(397)))(545(979(268(356)(695(9(554(795)(609))(879(246)(567)))(388)))(829(508(635(837)(97(994)(564)))(751(634(998)(880))(6(279)(317))))(710(20(173(27)(182))(520))(935(977)(680)))))(854(990(423(1(367)(152))(503(794)(143)))(605(602(170(788)(829))(899(244)(778)))(886)))(253(195(336)(123(90)(905(734)(111))))(298))))))))) +(430(653(443(105)(232(443)(42)))(720(69)(892(555(236(236(980)(424(469)(333)))(228(829)(355(657(816)(411))(562(54)(807)))))(385(785(31)(114))(731(103(730)(486(757)(770)))(503(497(323)(219))(689(763)(502))))))(372(788(972)(269(793(698)(859))(965)))(765(418(334(663(588)(399))(244))(373(614(897)(232))(488)))(476(723)(568(426(284)(818))(739))))))))(883(715(61)(760(128)(767)))(475(210(447(99(681)(66(942(563)(806))(545(541(975)(226))(549))))(317))(742))(384)))) +(352(389(685(369)(593(172(379(229(63(402(852(181)(832))(254(856)(917)))(105(86(732)(753))(896(39)(955))))(821(464)(58(475(779)(454))(567(152)(941)))))(24(640(873(124)(53))(133))(479(444(887(776)(733))(709(892)(564)))(1(872(756)(95))(834)))))(259(140)(920)))(130(834(312)(311(211(171(919(417)(990))(845))(353(877(718)(877))(483(413)(637))))(862(258(820)(61(820)(381)))(817(15)(156(613)(245))))))(506(762)(431(479(161(815(394)(90))(255))(191(300)(327(647)(268))))(461(397(548(465)(935))(513(736)(150)))(941(700(569)(788))(440))))))))(72(26(193(891(685(428(267(187(165)(175))(296))(440(659(408)(974))(826(365)(204))))(690(309(531(559)(333))(375(21)(529)))(357)))(837(106(729)(227(684)(357(257)(340))))(683(981(240(758)(494))(184))(550(250(438)(428))(161)))))(960(717(379)(94))(116(750(873(947)(195(130)(605)))(945))(194(806(633)(487(667)(607)))(790(897)(588(472)(873)))))))(959(975(691)(515(145(896)(917(688(384)(958))(109(503)(752))))(905(139)(826(880(748)(789))(202(76)(0))))))(541(705(249)(165))(703(580(959(950(607)(756))(909(208)(648)))(337(749(550)(167))(555)))(225)))))(36(607(941(821(926)(438))(951(523)(268(878(448(300)(917))(942))(678(364)(37(438)(650))))))(286(204(978(35(726)(229(615)(151)))(94(384(482)(625))(792(621)(535))))(370(377(925)(109))(887)))(726(935)(535(20)(736)))))(140(782(755(626)(319(834(461)(547(348)(824)))(531(671(692)(45))(504(663)(858)))))(913(933(72(774)(897(82)(106)))(636(179(749)(526))(24(869)(801))))(738)))(513)))))(735(739(276(620(147(78(148)(941(336(190(475)(408))(489(902)(249)))(293(749)(522))))(232(916(498(703)(983))(408(659(533)(54))(986)))(899(272(948(829)(595))(627))(892(153)(534(339)(421))))))(887))(484))(157(328(120(516)(517(108(321(930)(883(902)(752)))(273(474(612)(204))(419(175)(199))))(756(907(195(296)(582))(309(943)(787)))(946))))(780(339(328(371(289(330)(232))(602(508)(420)))(36(271(563)(440))(593(692)(809))))(909(831(64)(961(509)(409)))(77(672(822)(750))(111(952)(397)))))(974(850(481(872(264)(975))(435(255)(791)))(786(823(696)(180))(235(636)(437))))(486))))(391(270)(732(870(810(665(338(55)(387))(20))(755(131)(876(585)(385))))(528(157(153(816)(48))(717(158)(755)))(752(804(112)(198))(208(592)(593)))))(23(368(82)(61(107)(756(603)(49))))(418))))))(822(294)(495(158(214(764(626)(426(327(657(29)(219))(668(153)(885)))(619(985(693)(923))(976(216)(261)))))(778))(932))(415(50(224)(348(688(384(893(99)(249))(188))(513(739)(173(870)(919))))(352(83)(693(815)(896(354)(706))))))(137(283)(247))))))) +(386(254(927(22)(509(232(22(538)(664(938(400(493)(687))(410(971)(401)))(12(736(513)(770))(11))))(365(24(162)(127(784)(214(340)(447))))(118(163(637(140)(487))(626(437)(361)))(357(108(100)(391))(919(193)(400))))))(851)))(635(477(784(468(473(475)(436(594(668)(40))(445(615)(760))))(934(709(987(115)(59))(7(620)(234)))(76(425(122)(219))(661(945)(169)))))(275(854(286)(434(915(845)(111))(527(627)(491))))(639)))(32))(977(157(727(959)(923(912(702(636)(512))(537(811)(622)))(509(904(619)(831))(260))))(287(102(275(472(292)(395))(277(805)(264)))(979(869(595)(842))(315(827)(425))))(12(522)(377(942)(208(418)(232))))))(923(216(403)(849(533(768(467)(926))(847))(762(82)(316))))(349)))))(133(728(783)(70(924(975(995(983(285(623)(181))(288(284)(205)))(389(131(192)(115))(303)))(75(571(828(500)(307))(467(442)(846)))(183(103(44)(647))(419(204)(180)))))(287(656(394)(990(584(693)(759))(108)))(616(883(31(854)(323))(633(589)(887)))(706(223(586)(474))(404)))))(767(472(851)(351(270(970)(82(548)(128)))(347)))(242(588(58(961)(30))(275))(737(437)(101))))))(55(266(252)(149(36(9(262(861(8)(350))(910(337)(513)))(660(900(338)(740))(291(31)(269))))(744(704)(502(842(740)(110))(193(608)(975)))))(465)))(933)))) +(437(610(409(875)(468(741(136(542)(641(978(972)(426(664(906(465)(739))(550(261)(104)))(869(712(274)(550))(600))))(256(360(910(406)(724(30)(686)))(204(673(684)(467))(35(156)(397))))(807(417)(200)))))(866(793(351(891(403(332(681)(146))(708))(679(581(501)(2))(620(9)(389))))(841(854)(533(49(300)(226))(56))))(560))(416(879(387(824)(646))(417))(728(829)(291(887(349(965)(549))(628(226)(903)))(660(76)(108(595)(26))))))))(869(484(813(138(197(497(723(641)(739))(382(670)(363)))(806(968)(260(876)(867))))(71))(259(289)(578)))(423(90(683(816(171(545)(8))(264))(134(832(310)(539))(822)))(981(621(343(431)(78))(512))(341(145(862)(487))(683))))(670(429)(461(672(27(55)(393))(263(464)(654)))(986)))))(587(103(203(68(521(39(183)(954))(779))(331))(360))(895))(145)))))(883(420(581(639(522(73(225(103(925(622)(543))(398))(771(37(469)(20))(472(215)(532))))(891(187)(640(321(387)(69))(183(881)(396)))))(833))(572))(241(918(770)(411(912(516(14(205)(586))(919(541)(543)))(420(711(813)(314))(478(747)(773))))(322)))(601(193)(740))))(531))(550(809(942(38)(608(699)(827(114)(502(937(84(725)(31))(831(275)(531)))(836(614)(350(926)(28)))))))(488(911(868)(439(53)(323(151(970(331)(29))(13(82)(708)))(198))))(489(64(489(788(202(841)(924))(564))(600))(759(515(397(941)(945))(416(419)(784)))(11(253(173)(933))(51(604)(140)))))(657(248(277(40(243)(240))(48))(696))(445(493(177(646)(120))(764(59)(261)))(590(60(733)(385))(673)))))))(518(873)(289(353(294)(939))(643(515(461(702(164(910)(857))(777(131)(576)))(299))(345(457(349(876)(544))(607(873)(413)))(330(820(875)(248))(240(185)(874)))))(959(189(164(324(304)(413))(845(154)(698)))(462(513(776)(97))(566(152)(256))))(153))))))))(331(26(671(101(994(136)(145(680)(389(813(724(102(569)(85))(62(845)(127)))(315(286)(224)))(271(845(666(416)(789))(781))(18(936(464)(742))(242(76)(233)))))))(661(597(934(335(673(493)(501))(329))(761))(464(284(212)(993(190(643)(692))(393)))(853)))(869(608)(610))))(726(895(85(494)(961(865)(140(794(507)(683(487)(963)))(560))))(230))(542(570(140)(485))(952(301(100(559(621)(388(290)(283)))(471(213(967)(503))(304(341)(153))))(710(159(875(909)(213))(356(651)(726)))(226(474)(620(923)(209)))))(259(759)(96(411(399(68)(891))(340(150)(890)))(552(472)(429(27)(647)))))))))(594(885(42(513(634)(430(722(874(930(298)(493))(888(124)(509)))(134(483)(835(42)(227))))(158)))(900))(161(138(674(39(277)(919))(642(871(81(775)(601))(850))(994)))(909(552)(846(935)(655(628)(530(932)(787))))))(437(6(237)(892(363(352)(792(667)(17)))(754(243)(11(843)(764)))))(196))))(214(749(722(480(46(129(227(682)(361))(531(95)(701)))(684(880(779)(884))(826(137)(723))))(782(809(887(419)(727))(562(767)(316)))(177(660)(164(823)(889)))))(876(269(968(957(754)(220))(273(219)(139)))(158))(304(477(638(601)(727))(280))(686))))(896(232(267(836(139)(394))(580(653)(394)))(683))(662(223(857)(491))(270(380)(909(138)(85(553)(701)))))))(943(608(326(69)(437(114(562)(724(235)(946)))(786(629(624)(64))(918(148)(632)))))(867(600)(319(894)(118(66(508)(942))(753(43)(90))))))(142)))))(227(739(957(778(958(637(604)(521(323(681)(406(536)(283)))(911(789(798)(450))(195))))(359))(393(619(663(938)(113(69(270)(947))(665(657)(558))))(964(275(959(815)(724))(568))(225)))(845(247)(425(896)(367(917)(197(475)(139)))))))(817(215)(63(528(280(459)(873(158(593)(661))(862(12)(514))))(86(412)(183)))(680(125)(834(619(769)(382(899)(273)))(484(145(633)(989))(47)))))))(817(341(233(232(104)(563(938)(365(20(387)(134))(638(424)(450)))))(720(378)(593(807)(800(390)(91(915)(987))))))(673(536(696(180)(876(861)(963)))(509(103(409(61)(341))(639(931)(187)))(134(83(615)(933))(859))))(373(61(709(612(141)(118))(982))(902(913(747)(565))(755)))(193))))(524(132(754(78)(194(785(156)(481))(769(894(732)(25))(278(826)(480)))))(511(9(301(866)(987))(976))(433(781(433(216)(797))(925(670)(128)))(868(847)(299(468)(530))))))(712(468(482(15(38(818)(333))(629(857)(979)))(132(276)(685(563)(590))))(525))(918(44(261(180)(935(329)(892)))(263))(895))))))(64(366(892(954(932(660)(664))(825(98(163(330(23)(164))(160(126)(720)))(481(529(421)(959))(285)))(161)))(883(755(139(232(241(422)(536))(653(754)(643)))(980(417)(865)))(170(65(689(240)(962))(485))(784(964(339)(788))(15))))(444(766(894(729(234)(723))(55(544)(537)))(566(493(821)(677))(77(756)(32))))(584(682)(525(173)(16(913)(125)))))))(223(303(110)(481))(893)))(67))))) +(414(317(558(596(895)(972(651(698(229(857(482(170)(799))(929(77)(890)))(368(487)(324(812)(731))))(50))(312(98)(513(678(275)(171(430)(943)))(771(685(238)(843))(29(360)(759))))))(900(511(452)(536))(15(998(352(183(828)(415))(391(488)(705)))(586))(119(793(701)(81(408)(793)))(887(614(511)(456))(441(867)(910))))))))(458))(269(641)(181(158)(956))))(526(636(343(943)(105(786(324(650)(775(780(200(819)(818))(641(389)(246)))(561(221(148)(695))(358))))(740))(98(783)(89(495(705(630(869)(426))(734))(221(731(178)(968))(623(565)(233))))(569)))))(397(787(317(462(29(57(698)(752(669)(105)))(166(14(384)(612))(714(586)(717))))(227(452)(656(504(100)(222))(191))))(271))(975(930(686)(353(784(453(288)(214))(598))(725)))(779(294)(450(264(682(360)(36))(563(867)(578)))(998(836(99)(542))(499(52)(342)))))))(624(866(501(51(58)(916(908(341)(833))(165(139)(333))))(503(278)(646(787)(668(664)(783)))))(380(643(949(529(350)(390))(753))(94(992)(151)))(181(269(301)(755(683)(307)))(719(235(710)(677))(88(345)(168))))))(735(780(245(454(701(220)(299))(520(332)(732)))(114(530(11)(477))(754(208)(652))))(469))(226(742)(169))))))(490(202(971(770(338(538)(256(195)(757(740(282)(152))(226(796)(423)))))(462(437(368)(875(243)(8)))(275)))(594))(246(152)(684)))(148)))) +(226(770(234(350(271(866(603(770)(728))(62(659)(52)))(425(685(836)(716))(515)))(965(414)(914(192(628)(92))(279))))(937(993(268(13(81)(958))(169(878)(203)))(169(911(711)(4))(370(58)(352))))(517(494(283(988)(9))(785(680)(379)))(725(298(639)(416))(50(265)(167))))))(757(921(180(97)(690(717(984)(312))(877(248)(964))))(213))(37(671(376(391(845)(557))(468(201)(491)))(392(592(31)(565))(544(171)(569))))(228(246)(799(106)(149(885)(290)))))))(181(849(630)(959))(361(824)(307)))) +(174(201(356(540)(797(158(446(853)(734(573)(265)))(326))(288(205)(579(261(162)(623))(382)))))(814(343)(862(841)(681))))(554(169(416)(3(417(144(260(317)(916))(70(791)(109)))(272(128(333)(414))(755(634)(697))))(556(75(438(809)(857))(164(550)(576)))(298))))(330(753(137)(300(294(343)(896(959)(706)))(818(32(386)(80))(202(95)(785)))))(497(407(822(318(344)(197))(319(777)(113)))(836))(989(703(691)(164(165)(498)))(175)))))) +(396(724(264(500)(455))(328(15(925)(274(524(427)(509(164)(400)))(380(845(545)(369(845(278(184(37)(850))(769(552)(647)))(729))(96(191)(573(803(970)(526))(21(295)(844))))))(484(239(28(979(557(805)(153))(951))(646(358(50)(890))(374(522)(289))))(478))(755)))))(376(615(589)(799))(811(93(51(815(83(836(958)(376))(455(197(975)(653))(367(654)(945))))(968(399(347(94)(187))(567(12)(809)))(515)))(72))(281(839)(449)))(857(583(135(93(183)(589(625)(617)))(538(847(940(191)(619))(726(240)(167)))(67(667(650)(944))(839(750)(238)))))(9))(463(912)(104)))))))(427(490(126)(405))(27(579(454(260)(550(395(878)(278(811)(311(97(14)(257(342)(399)))(478(213(763)(510))(927)))))(749)))(820))(744(864)(159(932(266(123(743(753)(491(481(725)(472))(830(564)(241))))(133(133(116)(453))(312(627(299)(190))(114(813)(347)))))(662(773(853)(440(688(297)(268))(511(137)(795))))(779(373(816(705)(702))(924))(713(738(436)(303))(28)))))(57(782(367(726(528(347)(357))(281(746)(892)))(87))(548(673(18(544)(41))(766(489)(496)))(935)))(792(417(34)(77(228(640)(148))(634(811)(990))))(184))))(83(682)(46(520)(914)))))))) +(812(323(627(316(479(971(438(688)(333))(422))(646))(914))(102(662(772(43)(681(862(35)(729))(830(24)(926))))(509(38)(844(833(627)(80))(655(803)(389)))))(327)))(178(678(626)(182(176)(294(484(346)(161(814)(308)))(824))))(814(310)(226(800(76)(785))(62(649)(946))))))(210(144(274(179(932)(437(754(242(78)(154))(250))(838)))(306))(309(289(895(916(850(962)(971))(452))(512(132(64)(845))(780)))(374(85(761(428)(223))(804(425)(339)))(523(912(690)(733))(441(112)(833)))))(463(408(318(807(334)(162))(911(256)(841)))(529(607)(334(116)(13))))(239))))(203(161(534)(602))(353)))) +(529(760(402(704(675(10(513(363(340(934(195(916)(190))(369(989)(160)))(65(725(236)(49))(404(454)(220))))(933))(205(727(481(580)(191(285)(120)))(47(607(151)(619))(661(821)(740))))(551(463(635)(380(267)(667)))(676(395(496)(510))(91(495)(824))))))(803(445)(675(773(217)(173(331(823)(234))(20(311)(289))))(951))))(682(901)(504(415(677)(679(985)(38)))(380(331(294)(371))(23)))))(752(341(66)(6(413(854(585(691(853)(295))(343(494)(831)))(997(359(156)(114))(137)))(923(116)(733)))(389(723(815)(956(498(933)(659))(406(167)(199))))(771(180(96(673)(701))(667))(857)))))(615(609(993(822(594)(450(606(208)(422))(564(866)(486))))(447(193(196(582)(765))(840(842)(614)))(615)))(899(595)(67)))(661(285(98(718)(726(414)(509(630)(184))))(164(619)(710)))(390)))))(342(468(60(437)(15(233(843(863(980)(324))(982(649(947)(683))(593(601)(330))))(269))(838(759(968(750(841)(653))(435(727)(913)))(241(94)(670)))(555))))(936(718(573(925(734)(537))(542(228(424(387)(315))(426(795)(781)))(67)))(680))(933(107(472(355(218(193)(270))(623(394)(818)))(181))(701(870(542(111)(554))(419))(310(933(726)(117))(255))))(123(813(749(352(404)(990))(766(113)(7)))(5))(825)))))(545)))(616(338(541(34(916(172(382)(921(114)(773)))(704(448)(980(927)(108(737(367)(28))(608)))))(865(591)(499(949(592(431)(765))(20(309(726)(502))(712)))(148(173(257(159)(117))(135))(900)))))(874(628(960)(676(531(334(438(469)(846))(230(725)(585)))(735(53)(628)))(684(850(63)(950(673)(274)))(544(12)(988)))))(33)))(122))(343)))(52(226(251)(375(507(538)(940))(608(315(400)(300(460)(782(802(148(779(358)(959))(829(333)(525)))(429(921(686)(402))(146)))(678))))(659))))(99(669(111(66(742)(777(944(343(411(683(839)(322))(118))(684))(838(311(352(50)(362))(634(573)(323)))(775(4(654)(233))(162(449)(909)))))(528(130(110(469)(116(923)(663)))(524(958(887)(814))(654(69)(59))))(903(310(138(290)(752))(100(508)(513)))(950(678(19)(512))(898(908)(968)))))))(56(730(756(786(46)(827))(775(28)(772(836)(607(883)(120)))))(438(821)(612(258(247(539)(771))(318(581)(427)))(159(483(159)(66))(304(791)(807))))))(397(211(496)(444(342(237(816)(723))(995))(508(822)(549(275)(604)))))(252(515(718)(525))(898(630)(992(378)(701(451)(738))))))))(197(92(243(214(743)(72(32)(309(205(94)(778))(774(508)(252)))))(50(197(789)(261(918(894)(916))(761(138)(820))))(107)))(477))(463(499(213(452(805(158)(885(120)(892)))(990(860(336)(760))(352(818)(734))))(546(729)(813(621(707)(441))(661(36)(827)))))(658))(705(787)(623(51(386(360(800)(253))(502))(702(912(386)(632))(170(648)(869))))(195(426)(804(434)(446))))))))(684)))) +(212(454(677(225(655(101(997(203)(529))(976(769)(58)))(800(500(517)(747))(665)))(874))(581(189)(215(89(838(367)(820))(614(107)(320)))(475(399(110)(997))(223)))))(245(855)(869(885(813)(388(243(338)(188))(221(898)(482))))(7))))(153(228(330(448(181(26(287)(246))(855(193)(404)))(472))(146))(41(696(432)(798))(514(235(779)(884(71)(503)))(941(509(575)(216))(521(827)(234))))))(649(937)(778)))) +(629(269(370(416)(444))(951(570)(665(782(695(691(931)(813))(315))(60(616)(12(181(945(261)(669))(525(487)(907)))(983(75)(503(592)(360))))))(501))))(310(186(101(736(472(857(451)(842(473(429)(420))(255(348)(309))))(783(356(881(598)(22))(884(504)(125)))(64(94)(525))))(905))(314(286)(696)))(3(454(85(2(292(126(568)(172))(833))(515(881(360)(773))(694(276)(91))))(387(896(266(610)(815))(726))(507)))(352(865)(244)))(106(146(829)(419(130)(393(249)(278(736)(294)))))(716))))(206(53(604(693(635(646(690(759)(493))(27))(980))(376(770(790)(277))(936(829(971)(234))(946(82)(374)))))(351))(678(204)(423(215)(963(11(13(602)(734))(305(196)(671)))(442(317(340)(705))(173))))))(393(32(174(436)(334))(536(147)(324)))(991))))) +(366(957(843(140(214(755)(408(487)(162(452(225(281(863)(484(68)(68)))(309))(428(59(752(29)(49))(786(515)(321)))(78)))(882(125(279)(983(141)(503(129)(777))))(688)))))(939))(148(869(249(302(563)(28(597(505)(616(597)(685)))(215)))(382(553(790(416(950)(433(507)(276)))(28(798(905)(20))(789(934)(213))))(889(888(623(13)(47))(838(861)(296)))(604(544(382)(580))(18(371)(605)))))(572(380(602(37(955)(885))(720))(452(232(275)(1))(999(383)(338))))(100(724(617(900)(719))(658(560)(790)))(632(750)(98))))))(886(691(96)(504(112(453(611(124)(792))(620(850)(228)))(313(128(230)(326))(195)))(50(853)(41(459(856)(317))(4)))))(380)))(955(790(670(706(37(725(635)(336(690)(909)))(215))(983(977(258)(865(438)(688)))(414(206(921)(850))(77(384)(913)))))(973(700(202(395(908)(308))(266(836)(326)))(909(11)(873(986)(262))))(797(421(968(794)(755))(235(13)(53)))(336(195(938)(140))(637(257)(609))))))(979))(379(144)(445(825)(128(710(990(606(896)(992))(238(845)(804)))(942(547(901)(911))(913(865)(26))))(25(728)(603))))))))(33(880)(5(597(277)(347))(240(374(119(609(69(496)(354(5(689)(927))(553(2)(902))))(743(711)(929(792)(897(560)(348)))))(570(48(434(107(519)(310))(182))(704(621(759)(64))(841)))(204(448)(525))))(618(645)(877)))(468(852)(527))))))(629(75(638(587(475(847)(337(861)(157(769)(31(28)(900)))))(161(780(299(700(189(566)(779(517)(536)))(517))(893(784(2(25)(277))(548))(519(388)(318(441)(185)))))(813(197)(503(577(597(806)(341))(240))(354))))(540(857)(444))))(863))(837(719(189)(796(778(401(79(663(492(947)(970))(575(586)(577)))(52(592(352)(46))(160)))(416(274(898(448)(846))(983(73)(381)))(90(874)(924(254)(244)))))(402(925)(295(149)(537(195(632)(820))(25(151)(734))))))(614(299(449(431)(534(787(548)(262))(821(622)(657))))(711))(478(564(988)(44(752(65)(969))(245(769)(390))))(705(613(596)(941))(326))))))(128(647(353(303(587)(212(556(674)(276))(657(67(405)(496))(886))))(917(544)(723(531(794(97)(337))(587))(879(532(858)(257))(381(567)(612))))))(6(386(599(323(772)(287(449)(323)))(642))(73(463(222(813)(637))(14(880)(303)))(19(458(231)(527))(612(638)(799)))))(389)))(182(291(132(352(700(170)(496))(158(931)(489(788)(104))))(312(7)(843)))(279))(654(397(729(6)(188(459(187)(646))(851(963)(328))))(488(614(117)(668))(243(259(999)(468))(779(198)(752)))))(670(553(445(392(191)(557))(207(119)(96)))(181))(190(767(898(1)(588))(504))(462(661(546)(40))(593(49)(876))))))))))(92(629(253(115)(327(441(737(778(393(865(387)(977))(663(468)(881)))(123(170(273)(117))(55(89)(2))))(469(912(869(676)(960))(290(21)(139)))(817)))(257(5)(484(978)(707(896(74)(967))(902)))))(136(603(381(691(230(108)(293))(497(2)(302)))(186(198(184)(901))(788)))(344(429(798)(80(626)(45)))(254)))(206(33)(18(547(293)(733(555)(834)))(70(509)(352)))))))(80))(283(851)(366(412(26(118(67(946(883)(510(303)(716)))(474))(746))(156(610(67(749(524)(376))(801(246)(982)))(919(626)(630(829)(396))))(858(612(157(285)(201))(868))(579))))(955(467)(974(296(545)(587))(451(594(99(483)(313))(359(323)(228)))(375(150(69)(958))(388(660)(995)))))))(372(785)(496(684(207(791)(196))(93(156(803)(649(706)(323)))(573(902(558)(742))(824(829)(775)))))(235(659(57(222(519)(237))(952(682)(329)))(487(929)(805)))(95(115(18)(518))(985(403)(793))))))))))) +(365(425(1(856)(393))(741(830)(219(688)(615(33(619)(964(346(686(668)(209))(223))(256(928(94(799(619)(18))(48))(114))(110(393(722)(557))(628(609(476)(582))(158))))))(308(755(419)(160(389(653(673(126)(340))(264))(561(185)(861(231)(726))))(674(771(648(642)(483))(569))(628(502(822)(625))(916(168)(596))))))(733))))))(364(49(346(165(938(721)(951(618)(741(323(244(285(532)(936))(647(422)(855)))(665(198(28)(352))(952(115)(922))))(721))))(608(779)(856(193(681)(794))(629(635)(506(342)(953(179(399)(189))(617)))))))(94))(739))(884(604)(581(49(189)(653(576(734(415)(682))(291(52(494(798(401)(928))(613(181)(151)))(956(807(119)(992))(151(458)(580))))(293(877(986(725)(342))(47))(701(300(809)(477))(63)))))(250(300(671(73(431(866)(323))(563(480)(79)))(384(291(881)(609))(24(736)(946))))(60(52(560)(222))(921(834(570)(807))(579(944)(394)))))(934))))(775(972(919(23(95(852(874)(305(457)(808)))(589))(324(122)(991(990)(324))))(618(814)(551(442(364(868)(963))(531(36)(475)))(551(176(276)(496))(802(749)(115))))))(939(531)(686(779(466(733(708)(15))(167(26)(582)))(742))(227(698(795)(224(73)(198)))(484(364(36)(286))(510(466)(548)))))))(251)))))) +(963(87(648(755(191)(334(790(853)(584(434)(84(13(549(699)(53))(429))(871))))(71)))(51(823)(977(2(252(316(345(142)(594(198)(697)))(934(992(916)(817))(600(337)(603))))(867))(344))(262(914(241(32(52(95)(174))(381(384)(158)))(110))(733(200(273)(211))(844(536(625)(167))(293(61)(283)))))(808(189(617(742(924)(812))(508(217)(394)))(100))(908(330)(754(499)(585(354)(129)))))))))(461(950)(520)))(261(831(276(290(641)(101(343(566(278)(367(618(47)(595))(358(328)(537))))(149(684)(612(805)(769(816)(578)))))(280(258(825(926(879)(606))(193))(564))(71(630(293(732)(946))(712(473)(625)))(374(67(218)(854))(895(862)(220)))))))(957))(861))(661(64(880(162(868)(654(251(465)(650(708(567)(669))(480(629)(825))))(734)))(743(413)(776(282(374(680(629)(384))(651(574)(174)))(357(835)(514(434)(570))))(904(994(219(989)(679))(977(539)(365)))(804(255(405)(986))(76(170)(185)))))))(457(230(341)(892(678(70(654(201)(978))(422))(502(312(773)(106))(857(770)(750))))(824(52(654(397)(186))(862(907)(82)))(960(239)(298(551)(854))))))(116)))(352(929(110(132(637)(12))(114))(565(540(413)(314))(39(287(826(757)(642))(398(916(351)(451))(925(909)(727))))(521(751(437(18)(293))(611))(23(665(487)(873))(609))))))(603))))) +(991(212(432(0(746)(924))(617(505)(327(629)(597(321)(836)))))(389(984(521)(38))(514)))(310(341(782)(246(222(564(951(759(323(682)(259))(532(407(680)(494))(754)))(83(634(232(70)(72))(515(588)(644)))(968(267(985)(86))(239(335)(637)))))(437))(751(53(581)(353(191(675(402)(120))(189))(787(559(285)(474))(765))))(126(168)(235(777)(264(685)(968))))))(39)))(804(817(424(512(887)(134(603(807(360(348)(254))(468(10)(352)))(829))(445(471(447(45)(637))(669))(720(938(560)(221))(510(609)(510))))))(204))(706(528(498)(769(667(915)(36(332(635)(584))(626(599)(888))))(690(287)(173(412(571)(630))(273(434)(874))))))(775)))(354(269(109(379(258(542(754(774)(853))(537))(502))(713(582)(605(662(755)(36))(575(172)(227)))))(292))(147))(130))))) +(507(30(140(749(204)(234(249(554(539(836)(9(663)(437)))(722))(768(160(624(127)(783))(865(41)(793)))(310(742)(694))))(153(715(887(272)(525(627)(399)))(612(627(65)(560))(680)))(237))))(378(222(49(196(434)(118(675(755)(719))(498)))(401(105(363(19)(548))(569(352)(715)))(657)))(378(957(613(395)(518(133)(545)))(967(570)(607(961)(245))))(530(625)(75(76)(901)))))(174)))(762(847(530(373)(55(480(32(554)(387))(161))(563)))(501(3)(109(769(251)(323))(833))))(152(928(233(535(161(838(913)(61))(816))(673(375)(131(451)(543))))(121))(10))(827))))(989(850(965(986)(894))(674))(157(71(400(659(794(17(703(544)(549))(732(707)(499)))(529(939(253)(588))(986(920)(589))))(146(317)(939)))(364(881)(801)))(919(589)(344(827(329(206(812)(910))(238(627)(182)))(488))(113(867(813(457)(886))(74))(352(447)(246(590)(707)))))))(148)))) +(494(696(54(206(236(544(467)(226))(932(327(332(425)(940))(751))(463(571)(768(860(652)(778))(423(87)(479))))))(916(850)(271)))(404(929(457(922)(187(394(176)(46(899)(232)))(208(753(644)(718))(746))))(841))(789(659(902(481(964)(767(273)(745)))(988(808)(188(529)(545))))(656))(545(953)(512(638(273)(200(915)(751)))(960(255(752)(880))(794(593)(953))))))))(250(534(470(889(676)(268(654(520(730)(156))(506))(721(991(574)(253))(495(93)(766)))))(132(282(138(973(731)(1))(795(312)(496)))(292(371(909)(322))(423)))(54(789)(388))))(730(343(332(395)(694(586(468)(344))(282(335)(64))))(427(515(500)(221(958)(465)))(597)))(427)))(554(581(59)(569(50)(88)))(359))))(839(328(939(877(699(624(810(551(635)(239))(914(691)(577)))(933))(710(225(187)(353))(23(352(375)(186))(731(1)(277)))))(735(917(439(619(979)(311))(820(210)(117)))(484))(425)))(239(593(210(986(716)(381(860)(732)))(741(3(661)(971))(968)))(526(264(532(364)(340))(740))(324)))(202(272(125(388(418)(162))(333))(130(12(428)(185))(284)))(0(219(632)(812))(632)))))(808))(662(13)(410(443)(375(635(816(757(769(636)(739))(629(988)(248)))(476))(719(224)(728(329)(386(706)(693)))))(181(366)(595))))))) +(420(450(527(243(482)(130(199)(34(648(718(993)(215(748)(563)))(290))(303(698(917(854)(324))(966(37)(947)))(471)))))(552))(487(216(910(604(465)(982(813(831)(788(115)(31)))(572(470(43)(315))(330(991)(688)))))(635(974)(389)))(910))(439(640(836(95(130(410(757)(649))(229(659)(705)))(675(477(505)(424))(752(130)(509))))(26))(691))(718(7(58(953)(840(530(594)(301))(243(955)(791))))(77))(55)))))(682(380(558(469(455(449(205)(757))(164))(439(358(104(781(962)(717))(938(624)(758)))(102))(778(841(607)(972(880)(945)))(156(948)(841(541)(423))))))(631))(241(346)(958(741(917)(949(97)(813(627(72)(872))(297(287)(312)))))(17(87(780)(636(515)(139(820)(616))))(890(921(246)(343))(111(599)(850)))))))(983(322(398(608)(801(479(700(448)(488(958)(783)))(30(334)(895)))(104(2)(620(333(722)(524))(470(73)(312))))))(402(860(82)(62(805)(158(286)(23(217)(376)))))(1(566)(976(254(112(77)(834))(75(626)(307)))(763(226(484)(362))(328(566)(758)))))))(406)))) +(443(975(318(463(260)(832))(968(854)(292(691(177(32)(79))(959(580)(51(293)(155))))(890))))(723(209(659(95(266)(684(903)(635(684)(170))))(403))(697(626(731(944(550)(454))(466(83)(755)))(272(455(879)(596))(752)))(377(492(973(823)(302))(173))(699(748)(776(48)(215))))))(443(812)(485(34)(120(456(633(357)(818))(777(500)(912)))(811))))))(144(595(370(489(847(151(607(959)(938))(364))(783))(680(228(339(983)(734))(554))(815(445)(798(669)(544)))))(146(830)(601)))(746))(553(279(72(742)(79(225(58)(146(672)(450)))(212(127(511)(916))(34(561)(148)))))(172(306(258)(8(532(374)(524))(951(381)(269))))(284(408(267)(821(129)(692)))(177(848(10)(944))(885(855)(510))))))(783(807)(271))))) +(455(339(734(839)(929(695(655(650(560)(829))(600(92)(660)))(997(442(697)(627))(664(471)(557))))(474(823(208(344)(744))(471(209)(566)))(947(999)(581(614)(767))))))(839(536(747)(881))(460(524)(252(829)(278)))))(228(853(925)(288(203(216(960(443)(160))(55))(993(385(170)(251))(419(390)(434))))(964)))(802(512)(956)))) +(73(767(422(408(82(896)(362(23)(82(839(488(228(339)(739))(891(977)(483)))(487(531(817)(36))(584(20)(773))))(437(89(372)(765(166)(72)))(376(824(195)(867))(397(225)(785)))))))(651(626(375(30(27(563)(960))(194))(92(937)(42(491(921)(302))(775(998)(930)))))(565(419)(441(992)(751(292)(517(436)(769))))))(807)))(1))(900(806)(189(650(16)(863(22)(339(845(46)(67(52)(389(641)(411))))(153(362(461(524)(310))(207(465)(275)))(311(17)(974(857)(716)))))))(683(618(381)(749(598(979(604(556)(698))(352(394)(913)))(36))(195)))(140)))))(478(532(738(352)(522(209)(627(837(624)(81(869(508(149)(313))(449(953)(683)))(40(833)(575(89)(307)))))(798(406(784(278)(671(275)(458)))(989))(644)))))(58(252(86(930(739(357)(846(626)(334)))(672(550)(754(796(868)(41))(316(331)(324)))))(164(148(310(169)(913))(804(824(859)(920))(243(67)(735))))(876(381(344(354)(15))(571(877)(29)))(419(282)(135(490)(581))))))(530(251(410(175(892(989)(834))(593(558)(235)))(811))(52(226)(511(646(443)(706))(704(217)(968)))))(984(443)(923(792(129(60)(420))(194(705)(291)))(409)))))(803(209(21(604(494(53(232)(704))(924(338)(746)))(891(87(133)(384))(669(195)(358))))(550(853(291(482)(815))(755(740)(7)))(490(104(201)(466))(303))))(602))(779(557)(86(677(524(636(579)(84))(96(173)(520)))(109))(168))))))(591(556(598(27)(457))(851))(542)))) +(65(232(525(329(183(74)(953(331(995(8)(128))(257(699(151)(934))(705)))(878(622(758)(327(246)(101)))(680))))(9(12(776)(174))(77(541(432(604(363)(98))(615))(586(266)(390(30)(372))))(785))))(199(20(593(884(271)(589))(609(519)(516(300(328)(211))(307(263)(359)))))(203(947(838)(42))(828(517(407)(485(886)(849)))(666(464(353)(684))(644(995)(720))))))(845)))(386(85(512(245(724(405(348(552)(382))(913))(669))(571))(834(781(185)(836))(843(909(36(65)(610))(142(505)(838)))(214(697(573)(881))(720)))))(507(553(159)(258))(847(122)(840(115(868(206)(662))(17(771)(982)))(572(290(24)(746))(666(783)(986)))))))(405)))(45(87(707(530(711(613(585)(947(823(635)(742))(315(82)(988))))(291(495)(433(749(570)(474))(592(823)(432)))))(712(629)(419(338(114(965)(419))(107(19)(335)))(674(720(910)(769))(25(210)(569))))))(711(78)(498(715)(674))))(721(187)(942(965(621)(433(57)(772)))(345))))(566(848(192(160(483)(390))(870(596(42(120)(366(485)(275)))(235(963(446)(869))(62(37)(354))))(603(457(678)(745(947)(28)))(614(495)(681(766)(588))))))(138))(617)))) +(475(409(68(109(84)(634(702(945(49)(477))(147))(287)))(356))(994(313(788)(151))(32(594(420(384(938)(491))(831(52)(196)))(338(402)(281)))(290(286(294(364)(927))(603(797)(200)))(348)))))(675(497(397(726(127)(444(891(993)(623))(327)))(586(8(118(300)(946))(716))(952)))(567))(326(805(989(391)(796(319)(436)))(747(802(189(416)(594))(772(951)(952)))(282(14)(97(830)(415)))))(977)))) +(131(145(274(990)(612))(201(139(655)(119(730(229)(803(80(312(811(374(959)(863))(180(867)(703)))(46(385)(79(181)(218))))(188(223)(956(487)(435))))(327)))(661)))(316(883(534)(315(803(248(251(84(788)(945(978)(483)))(309(321(656)(3))(49(464)(40))))(438(810(9(688)(994))(340(718)(852)))(28(175(949)(455))(559(609)(367)))))(225(828)(294)))(798(424(69(453(84(526)(852))(577))(811))(620))(789(560)(511(81)(324))))))(500(832(378(537(3)(156(942(768(149)(699))(286(917)(914)))(763)))(823(716(381(322(812)(237))(586(618)(644)))(222(479(446)(293))(306)))(850(379(563(383)(519))(371(752)(934)))(76))))(13(480(91(107(431(576)(52))(515(99)(812)))(237(68)(671(891)(809))))(69(255)(504)))(501(764(790)(687(246)(2(66)(306))))(682(560(31)(174(860)(794)))(922(533(593)(294))(870))))))(98(239)(857(491(684)(788(254(723(704)(180))(212))(167)))(54(404)(404(599(127(980)(956))(56))(801(569(267)(733))(841(871)(272)))))))))))(265(823(681)(373(261(54(471)(635(463(506(941)(860(184)(431)))(851))(435(741(26(790(871)(733))(944(526)(498)))(938))(1(211(92(981)(690))(534(499)(975)))(279(987)(129(195)(434)))))))(139))(587)))(608(72)(45(716(229(30(347)(773(265)(539(602)(912))))(455(907(859)(775(56(270(805)(884))(523(45)(342)))(219(215)(194))))(186(821(828)(978(555(971)(116))(106(575)(597))))(295))))(107(792)(237(451(219(517(252(114)(963))(374))(535(85(726)(941))(366)))(758(61(25(923)(539))(28))(76)))(843(382(584(813(123)(105))(712(953)(328)))(798(108(186)(828))(917)))(255)))))(418))))) +(642(524(376(111(612)(962(336(157(56(738)(252(164(990)(656(271)(12)))(262(406(250)(455))(478(42)(537)))))(822(408(51(318)(392(48)(402)))(995))(270(524(975(727)(246))(437))(86(369(747)(755))(909(697)(685))))))(982(492(787(914(671(617)(327))(512(365)(814)))(412))(534))(467)))(32(187)(103(343(605(727(330)(559(266)(489)))(889(901(248)(945))(212(393)(474))))(256))(361)))))(470(629)(738(786(518)(724(233(779(711(854(444)(615))(768))(765(607)(7)))(253))(220(979(350(21)(501(949)(739)))(662))(949(620(700(767)(294))(972(28)(892)))(784)))))(376(729(695)(476(683)(540(410)(646))))(142(398(241)(877(77)(539)))(133(930)(821(222(84)(554(120)(433)))(573))))))))(352(538(789(466(254(834)(778(295(698(428(103)(234))(736(107)(546)))(270))(47(262)(599(6(791)(409))(879(191)(795))))))(770))(830(172(671(405)(416(897(174(122)(680))(23(971)(498)))(702(422(17)(297))(44(368)(130)))))(918(540(154(576(86)(505))(397(116)(311)))(727(393(17)(25))(769(187)(675))))(311(222(381)(850(308)(584)))(396(557(609)(786))(471)))))(325)))(908(156)(506(640(283(270)(321(462(958(85)(914))(323))(978(502(59)(218))(971))))(614(626)(850(466(794(228)(720))(636(81)(636)))(657(628)(115)))))(173))))(851(127(444(242)(631(854)(803)))(458(956(354(217(377(363(688)(183))(745(722)(828)))(408))(831))(584(410(567(737(557)(575))(110(93)(779)))(143(620(853)(381))(505(313)(870))))(266)))(821)))(751(183(206(990(352(550)(926(883)(15(750)(654))))(336(869)(572)))(121(146(714(385(380)(320))(253))(578(671)(350(481)(50))))(849(555)(973))))(752))(478(587(951(117(521(175(525)(117))(929(64)(905)))(206(49)(611(312)(487))))(560(248(222)(543(880)(379)))(120(758(168)(492))(903(145)(161)))))(539))(789))))))(14(99(473)(822(49(960(325(628(511(515(738)(88))(49(765(549)(395))(932)))(227(565)(278(897(538)(991))(482(601)(112)))))(115(916(231(281(427)(360))(238(138)(172)))(797(83(422)(646))(680(365)(50))))(294)))(648))(64(7(52(684)(369(356(991(59)(748))(589))(924)))(24(401(293(470(417)(580))(435(640)(516)))(243(412)(222)))(342(849(557(962)(552))(89(707)(667)))(528(942(953)(49))(568)))))(143)))(222(564(438)(0))(352(947(593(508(73(712)(947))(422(445)(361(297)(141))))(180))(770(83(263(770(175)(137))(302))(849(102(115)(415))(688(553)(476))))(666(931(218)(60(411)(711)))(784))))(776)))))(694(519(226(181(19)(394(803(576(6)(284(915(177)(127))(326(132)(146))))(166(972)(996)))(437(920(652)(530))(397(38)(473)))))(324(683(726)(524(605)(1(866(967(955)(6))(21(278)(638)))(551(348(604)(628))(926(857)(758))))))(113)))(113(36(367(371)(810(859(312(908(95)(410))(892(248)(630)))(660(476(286)(727))(463)))(860(979(93)(358(10)(186)))(746(608(152)(391))(382(742)(606))))))(618))(85)))(387(861(385(498(101(91(949)(820))(728))(568(502(99)(723(322(530)(223))(698(610)(944))))(286(11(955(795)(607))(68(227)(138)))(520(786(945)(652))(944(174)(290))))))(984(954)(712)))(753))(826(632)(990)))))) +(856(996(876(525)(973(564(607)(316(599)(529)))(622)))(786(486(674(358(719(429)(742))(261))(161(73(586)(841))(772(653)(408))))(586(786(695)(126(280)(629)))(388(14(665)(143))(85(945)(797)))))(592)))(910(208(767(404(290)(386(813(29)(174))(849(265)(424))))(864))(432(381(689(684(299)(846))(205(911)(111)))(702(524(484)(236))(142(156)(705))))(985(63(450(144)(31))(841))(205(706)(597(685)(768))))))(862(332(227(563)(531(446)(844(191)(406))))(509))(992(560(921)(644(418)(519(178)(64))))(84))))) +(176(101(948(912)(486))(928(57(356)(199(755)(211(569(605(596(954)(618(319)(393)))(146))(890(855(688(129)(106))(982))(46)))(828(549(717(775)(460(58)(452)))(370))(708(506(313(442)(200))(521(62)(352)))(149))))))(64(150(4)(96))(944(30(619(77(587(701)(11(478)(837)))(984(547(148)(696))(773(262)(270))))(668))(802(166)(789(148(721(917)(265))(20(330)(271)))(155(608)(29(109)(950))))))(848(530(11(620(288(440)(906))(18(692)(294)))(296(335(256)(353))(499)))(872))(949))))))(819(68(181(382(370(295(681)(117(662(946(994)(184))(961(875)(933)))(221(242(919)(615))(197(155)(622)))))(587(718(490(708(555)(878))(635(316)(218)))(884))(231(280(186(96)(483))(828))(688(155(87)(185))(289(928)(929))))))(422))(968(809(918(289(663)(326))(453(20(518)(744))(96(267(972)(243))(239))))(738))(672(337(59(844(404)(403(572)(174)))(102))(675(832(699)(755(660)(825)))(345)))(401(226)(17)))))(25(120(102(301(260(830)(305(979(689)(549))(586(897)(364))))(579(177)(476(946(956)(947))(626(520)(711)))))(216))(692(457(731)(264))(372(846(4)(868(78(433)(303))(0(310)(211))))(311(790(151(876)(99))(181))(356(536(445)(745))(781))))))(919(736)(659(591(118(150(448(608)(362))(405))(991(485(84)(53))(964)))(611(758)(183(961(302)(811))(932(660)(977)))))(774(841)(995(332(10)(291))(963(387)(791(604)(888)))))))))(336(632(785(158)(771(554)(230(12)(510(528(812(803)(30))(504(577)(129)))(950(84)(521(626)(149)))))))(454))(226(380(215(777(654(50(965(970)(799))(556(859)(637)))(896(539(125)(419))(518(323)(687))))(504(59(674(743)(547))(490))(526(904(158)(916))(980(100)(389)))))(101(291(70(939(804)(239))(107(16)(310)))(914(364(583)(966))(333(593)(867))))(956)))(213(260)(568(407(697(761)(215(87)(576)))(598(467(555)(464))(940)))(137(613(562(256)(380))(973(194)(463)))(38(97(235)(534))(370(103)(831)))))))(779(877(268(508(434(316(812)(716))(631(905)(478)))(203))(700))(167(236)(524(846(117(676)(501))(402(71)(558)))(159(310(967)(491))(635(870)(178))))))(494(583)(54))))))) +(852(666(196(965(46(969)(50(560)(653(736(977(174)(799))(579(610)(187)))(535(224(319)(905))(659)))))(16))(823))(166(432(547(118(22(308)(222(604(187)(673))(810(780)(109))))(598(435(31)(945))(291(95(217)(110))(277(11)(311)))))(704(456(508(118(85)(886))(29))(614(497)(156(232)(940))))(768(756(268(535)(592))(302(651)(89)))(656(136(606)(255))(337)))))(5(615(988(615)(257))(289(279)(652)))(459(207(213(506(469)(919))(312(955)(974)))(210(94(775)(751))(114(374)(289))))(970))))(823(677(631)(111(23(70(252(833)(937))(96(627)(806)))(429))(849(810(700(99)(288))(809(712)(245)))(175))))(150(496(107)(967(247(953)(779(238)(795)))(707(186)(458(789)(128)))))(722(937)(694(205(529(73)(285))(608(130)(689)))(230(640(404)(451))(397(610)(485)))))))))(817(111(479)(493(640)(976)))(968(787(853(363)(810(352(620(800(398)(118))(63))(12))(35(515(828(570)(819))(866(586)(853)))(525(661(770)(93))(10(747)(545))))))(336(535(871(826)(918))(174(983)(152)))(551(175(758)(786(348(667)(264))(736(80)(377))))(471))))(338)))) +(159(588(648(580(809(334)(867))(720(992)(823(948(191(789)(447))(11(359)(278)))(932(524)(721(60)(137))))))(699(706(432)(424))(611(268(284)(505))(732))))(77(634)(587(495(920(97)(858(188(258)(356))(183(499)(877))))(374))(268(602)(266(32(176(989)(520))(615(969)(852)))(864(507)(112)))))))(141(659(312(679)(919(995)(909)))(188(274(613(941(33(898)(115))(664(417)(577)))(380(811(344)(209))(909(275)(408))))(103(817)(477)))(524)))(265(696(0(31)(444(296(920)(416(933)(798)))(235(869(622)(274))(401(169)(71)))))(611(515)(179)))(725(444)(536(990(419)(543(369)(498)))(141(984(858(914)(322))(340))(469(623)(285)))))))) +(336(864(658(181(900(275(751(471)(226(569)(643)))(648))(425(374(862(656(527(498(55)(653))(346(235)(476)))(438(714(588)(255))(411(829)(304))))(841(825)(327)))(210(639(586(677(84)(344))(593(334)(397)))(480))(555(30(7(941)(522))(320(862)(219)))(444(70(5)(734))(385)))))(7(553(547(466(45(793)(99))(982))(649))(244(382(782(140)(514))(664(584)(980)))(871(627)(457(816)(985)))))(705(612)(465)))))(859(44)(481(103(25)(283))(767(652)(772)))))(187(874(904)(407(225(368(745(743(32(334)(573))(337(243)(16)))(287))(380(80)(694)))(307(471(214(186(343)(653))(357(46)(263)))(845(250(20)(404))(814)))(492)))(318(602)(184(78(508(755(237)(697))(300))(12(269(860)(437))(35(952)(395))))(292(59)(173))))))(778(520)(61(146(876(761(700)(860))(525(179(275)(726(905)(322)))(438(198(574)(622))(228))))(858(365(670(485)(409(64)(234)))(213(582)(672)))(129)))(796(703(103)(49(599(219)(677(685)(280)))(210(881(922)(470))(38(421)(210)))))(266(95)(119)))))))(778(858(717)(534))(80(141(544(254(690(614(507(629)(10(300)(952)))(667(144(301)(209))(53)))(434(13(344(404)(324))(460(81)(926)))(711)))(875(51(112)(744))(875(164(686(561)(754))(866(448)(165)))(395(118(713)(700))(905(476)(590))))))(990(8(118(265(379)(543(7)(953)))(49(166(588)(695))(446)))(616(877(854(645)(206))(842(910)(94)))(9(440(734)(949))(873(555)(141)))))(532(934)(143))))(229(380)(642)))(568(820(462(665(264)(144))(840(671)(174)))(629))(731)))))(237(896(502(564(870)(392))(655(91)(821)))(448(51(63(690(471(562(296)(75(803(55)(176))(811)))(285))(837(105)(697(147)(32(984(270)(942))(180)))))(922))(922))(535(309)(421(420)(547(340(778(333(342(682)(773))(104))(684(410(822)(239))(851(768)(114))))(229(309(154(258)(459))(122))(88(661)(146(603)(508)))))(945(12(185)(792))(580(191)(396(399(728)(640))(496)))))))))(754(978(819)(263(522)(970(857(736(971)(961(126)(219(491(237)(736))(884(6)(52)))))(443(588)(973(328)(4(295)(922(5)(690))))))(466(464(223)(193))(665(940)(607(771(566(60)(804))(764(805)(19)))(31(826(212)(502))(735))))))))(335(216(662)(84(675)(410(987(823)(90))(768(625(375)(982(623(730)(312))(274)))(182)))))(375(892)(883)))))) +(577(685(6(618)(759(796)(450(498(2)(339(178)(280(991)(469))))(855(524)(759(916(197)(616))(787))))))(589(294)(184)))(930(157(636)(101(799)(349)))(703(983)(449(371(93)(739))(590(735(820(620)(972))(31))(523)))))) +(803(725(134(693(276(173(744)(147(680)(339)))(865(417(509(912)(113(923(505(82)(883))(176))(669)))(831))(922(388(330)(424(452(795(836)(21))(619(315)(562)))(104(455(168)(335))(569))))(697))))(722(896(266)(831(164(913(244(152(186)(342))(767(837)(285)))(764(655(924)(283))(707(306)(297))))(175(705(463)(177(871)(291)))(233(653)(60(706)(698)))))(601)))(339(615(626(368(682(485(608)(294))(638(458)(944)))(584(753)(754(690)(658))))(273(169)(548(205)(387))))(866))(999(620)(734(56)(269(139)(187)))))))(65))(418(8)(699(181)(343(846(769(306(78)(371(685(476)(573(435)(981)))(829)))(392))(110(763(638)(711(326(608(680)(30))(681))(205(257(337)(275))(260))))(702(133(103)(628))(610(59(971(323)(883))(368(741)(660)))(20(39)(637(424)(523)))))))(551(729(833(353(689)(263))(482))(544(498)(898(394(429(310)(93))(224(68)(996)))(773(410(321)(206))(382(854)(689))))))(961(477(987)(948(714(157(528)(742))(442(392)(673)))(378)))(319(964(947(923(811)(231))(78))(216(34(561)(536))(691)))(749(989)(793)))))))))(845(423(802(247(372(222(754)(822(238(538(820(148)(569))(83(14)(749)))(820(987(24)(795))(475)))(333(500(697(743)(402))(13))(977(894(744)(831))(728(286)(3))))))(356))(309(252(234)(69(689(813)(340))(701(153)(143(259)(422(48)(799))))))(102(103(496(30(453(291)(959))(377(533)(174)))(422(397(67)(719))(590(332)(260))))(957))(892(400(498(280(476)(834))(162))(125(467(630)(843))(221(604)(446))))(561)))))(922))(764(689(15(120(946)(743(330(596)(527))(779)))(306(947(412(717(787)(490))(906(497(849)(893))(3(433)(378))))(559(717(99(837)(414))(495))(319(623)(760))))(61(680(454(453(479)(206))(567(378)(718)))(669(193(223)(863))(188)))(332(727(577(518)(699))(866(56)(869)))(566)))))(800(860(985(205(148(141(644)(70))(35))(669(808)(191)))(440(648(384(870)(773))(217))(606)))(189(888(618(671(395)(223))(245(624)(662)))(458))(977(172)(500(340(837)(404))(848(189)(800))))))(619)))(625(424(2(876(229)(460))(243(186(741(201(218)(371))(218(473)(249)))(408(581(359)(788))(957)))(435)))(81(993(808)(983))(350)))(889(465(505(461)(670(462)(84(426(806)(377))(53))))(941(956)(551(823)(169(645(359)(643))(661)))))(544(644)(220(699(848(656)(672(163)(964)))(991))(794)))))))(67(500(240(344(375(288(923(979)(467))(191))(49))(328(451)(426)))(162(96(615)(78))(429)))(97))(512(387(310(138(735(1(749(227(983)(201))(828(691)(893)))(1(202(979)(25))(137(56)(497))))(332))(234(383(40(117)(686))(188(763(680)(955))(442)))(553(668(232(699)(219))(136(761)(530)))(81))))(618(959)(440)))(35(734(848)(641(796(503(133(290)(873))(172))(274(570(232)(809))(208(474)(588))))(871)))(486(146(694(82(655(89)(126))(222(268)(721)))(166(286(832)(166))(528(274)(860))))(609(951(420(665)(813))(841(783)(587)))(388)))(861))))(643(925(143(71)(704(542)(137(977(54)(602(103)(293)))(166(997)(327)))))(461(783)(466(545(772(584(890)(726))(462(654)(911)))(876))(251(330(776(291)(578))(545(295)(16)))(176)))))(640)))))) +(573(195(565(887(553)(947(759)(624(744)(995))))(460))(827(479(69)(436(220)(224)))(613(962)(235(134(395(96)(650(2(215)(389))(790(144)(392))))(390))(889(273)(811(124(627(832)(85))(193(540)(579)))(178(176(749)(716))(757(920)(935)))))))))(461(797(233(779(229(535(501(905(894)(663))(493(342)(123)))(266))(443(588(996(376)(964))(712))(11(735)(907(536)(937)))))(369(561(661(123(311)(172))(327))(313(107(545)(357))(701(283)(927))))(700(211)(281(378(496)(83))(719)))))(905(502(215(96)(45(651(418)(169))(846(950)(222))))(653))(499(512(177)(247))(286(309(437)(306(610)(659)))(681(21(603)(88))(336))))))(306(328(984(453)(693(975(540(857)(489))(117(735)(843)))(414(721(827)(250))(134))))(44(577)(168)))(454(999(662)(685))(745(905(977(286(648)(219))(433(105)(526)))(35(564)(112)))(368(809)(450(407)(849(82)(105))))))))(554(880(779(460(181(953(439(964)(897))(59))(929(302)(793(322)(757))))(29(947(324(921)(986))(241(237)(30)))(957(155(629)(455))(183(263)(773)))))(313(884(328)(487(151(246)(136))(316(567)(517))))(707(439)(37))))(522))(777(295(932)(649(223(699(651(542)(980))(46))(363(873(643)(427))(811(219)(314))))(970(188)(802))))(94))))) +(148(110(756(559(287)(578))(66(113(415)(320(364(636(995)(663))(101(538)(479)))(691(916(147)(404))(346))))(610(815(815(775(678)(598))(486(61)(340)))(154(578)(476)))(316(29(286(138)(871))(252(134)(609)))(116(415(708)(0))(511(213)(189)))))))(216(67)(466(999)(637(628)(83(367(636(225)(748))(779(908)(257)))(131))))))(64(826(945(229(308)(123(876(477(308)(319))(226(593)(597)))(290)))(935(931(149)(278(569(219)(357))(390(786)(615))))(151)))(957(25(950(877(90(855)(906))(692))(788(686(969)(182))(293(388)(32))))(662(63(582(900)(917))(256))(552(829(835)(955))(89))))(640(122(501(684)(152(372)(688)))(898))(9(52(528)(731))(946(26)(336(988)(581)))))))(839(307(660)(516(144(711)(605(39(489)(291))(763(359)(54))))(717(942(685)(892(52)(643)))(690(709(776)(996))(990(943)(962))))))(89)))) +(899(768(452(126)(211(769(533(767(835(530)(452(724)(998)))(473(609)(199)))(658(720(295(949(214)(990))(742))(658(361(14)(221))(739(147)(956))))(961(833(353(13)(682))(382))(505(306(5)(294))(293)))))(88(5)(60(164(151(611(920)(883))(302(478)(721)))(50(128(980)(267))(106(797)(814))))(952(524)(959(315)(595(469)(799)))))))(963)))(526(989(940(405(229(306)(310(349(38(828)(601))(887(621)(163)))(269(506(43)(386))(972))))(145(663)(545(406(682(645)(843))(48(286)(85)))(626(569(363)(994))(159(898)(324))))))(718(630(320(874)(703))(214(593(508(448)(695))(808))(945(606(725)(246))(446(949)(81)))))(246(18(695(384(595)(623))(505(772)(457)))(707(82(478)(886))(971)))(985(661)(741)))))(992))(834(313(446)(196))(325(993)(380)))))(853(668(806(258(427(645(35(568(76(935)(273))(690))(687(433(472)(548))(563(155)(118))))(597(70)(868(690)(749))))(562(124(508(43)(205))(14))(888(602(78(93)(914))(742(571)(985)))(476(663)(279(630)(219))))))(434(896(306(585(544)(862(498)(148)))(253))(719))(576(508(670(511)(939(466)(830)))(284))(138(740(646(624)(574))(29(144)(807)))(796(42(784)(264))(500(960)(447)))))))(49(713)(378(732(650)(702(783(320(538)(577))(249))(966(824(870)(272))(740(50)(339)))))(541(449)(521)))))(315))(556(330(759(648(924)(419))(968(332(146(872(999)(201))(351))(908))(253(479(863)(872(926(616)(418))(47(781)(609))))(276(570(772(137)(3))(493(137)(318)))(659(397(45)(440))(941(423)(311)))))))(3(302)(934(6(350(707(265)(372(954)(769)))(406(895)(832(274)(503))))(409(3(124)(399(223)(422)))(107(553(559)(930))(191))))(150(99(744)(784(713(291)(799))(68(905)(760))))(521(491(338(331)(519))(689(160)(261)))(471))))))(978)))) +(149(134(341(476(80(139(817)(642))(458(996(160)(784))(523)))(651(759)(412(819)(770(21)(488)))))(854(707(446(472)(722(765)(275)))(418(80(50)(193))(746(726)(241))))(430(369(450(763)(443))(737(914)(420)))(388))))(238(790)(295(554)(356))))(414(130(492(239(779(975)(105(992)(808)))(292))(89(773(468(99)(723))(688))(334)))(910(938)(650(947(266)(745(92)(143)))(344))))(82(446)(750(545(726)(275))(438(990(374)(571(418)(27)))(380)))))) +(227(232(166(722(506(717(947(527)(500))(563(67)(382)))(63(892)(954)))(665(44(330)(942(691)(618)))(465(593)(104(115)(202)))))(805(14(666)(659(256(927)(575))(536(33)(118))))(405(384(712(514)(50))(678(636)(563)))(133(938(191)(935))(246(572)(501))))))(625(942)(633(201(359(876)(296(672)(961)))(935))(772(478)(339(518)(257(119)(531)))))))(39(482(830)(738))(552(574)(230(52(396(596)(852(144)(702)))(959(35)(448(84)(280))))(478(82(764(856)(325))(235(639)(241)))(935(102)(955(903)(969)))))))) +(80(120(323(691)(921))(672(677(37(216(266(214(530)(786))(522))(440(892(374)(552))(874(459)(699))))(526(113(726)(612(381)(679)))(58(26(401)(490))(956(877)(154)))))(950(197(71)(253(687(573)(853))(873)))(94(936(179(383)(118))(916))(715(161(43)(708))(426(940)(855))))))(671(406(145(970(705(808)(61))(773))(27))(363(857(18(621)(646))(956(402)(553)))(244(997(851)(779))(877))))(229(540(684(512(98)(824))(270(0)(207)))(125))(849(489(255(375)(852))(749(328)(789)))(695))))))(943(462(816)(679(232)(737)))(83(813(553(973)(793(912)(111(744(68)(17))(751(319)(155)))))(421))(205(877(587(145(606(658)(119))(106(939)(254)))(342))(31(912(916(207)(170))(721(501)(219)))(876)))(242))))) +(361(590(696(221)(901(281(6)(151(879(581(678(61(910)(335(883)(850)))(594(951(207)(791))(305(765)(268))))(415))(620(147(147(77(408)(290))(964))(312))(306(160(401)(303(295)(310)))(623(240(822)(16))(954)))))(707(932(749(524)(421(347(502)(426))(391(359)(283))))(251(460)(422)))(152))))(901(26(82(374(22(937(669)(934(988)(456)))(849(320(362)(301))(994(929)(920))))(43(442(219)(621(470)(784)))(382)))(940(771(428)(419(888(604)(459))(545)))(262)))(103(98)(568)))(934(502(826(666)(149(746(544(937)(546))(970))(719)))(164(795(304(963)(331))(675(11(788)(417))(498(575)(876))))(785(290(137(190)(577))(282(759)(196)))(930(697(981)(532))(689(712)(899))))))(304(999(356(178)(95(356(607)(462))(949)))(970(474(38(75)(782))(665(296)(579)))(897(851(296)(235))(244(197)(831)))))(612))))))(522(581)(695(640(493(899)(657))(638(24)(186(128(325(356)(242))(271(415)(765(535(426)(625))(250))))(584(211)(876(82(51)(372(573)(200)))(54(423(34)(578))(669(121)(241))))))))(603(748(52(54)(73(322(931(897(481)(530))(872(314)(551)))(286(825(563)(898))(385(104)(872))))(949(256(34(829)(529))(310))(623))))(309(503(418(136)(331(218(926)(990))(879)))(649))(277(574(277)(762))(225(154(749(899)(415))(187(732)(587)))(713)))))(227)))))(308(903(529(654)(964(711(858)(739(417)(641(120(262(70(430)(586))(405(106)(981)))(185(198)(164(866)(279))))(196(594(708(898)(575))(955(359)(122)))(285(277(356)(940))(638(660)(861)))))))(457(717)(681(437)(199)))))(138))(858(54(193(612(808(544(865(733)(597))(598(215)(666)))(835(934)(450(103(601(482)(443))(881))(186(846)(518)))))(307(466(985(845(772(290)(104))(794))(453(986(870)(695))(367(769)(791))))(236(642(306)(411))(772(696)(198))))(783(156(744(841)(319(929)(303)))(868(711)(693)))(826(518)(49(422(71)(582))(281))))))(972))(146(808(483)(29))(51)))(18)))) +(788(640(948(971)(766))(483(209)(827)))(163(441(655)(638))(812(548(820)(913(798(680)(360(74(823(514)(470))(351(976)(887)))(576)))(537(935)(333(820(900)(256(766)(702)))(650)))))(722(234)(530(865(919(862(46(507)(813))(448))(661(946(721)(811))(927(61)(747))))(253(147(27(892)(843))(63(474)(603)))(198(279(811)(734))(85))))(378(717)(685(726(739(803)(243))(850))(995(140(902)(524))(757))))))))) +(857(510(140(224(959(282)(868(631(4(101)(627))(736(877)(858)))(358(67(502)(189))(352(957)(127)))))(261(463(110(448(380)(708))(877(11)(659)))(138(221(12)(707))(222(313)(983))))(351(42)(3))))(791(533(71)(178(246(996(22)(848))(6(160)(354)))(347(867)(633(333)(67)))))(410(963(372(274(162)(734))(401(130)(638)))(846(28)(872)))(589(341(910(158)(263))(365(715)(77)))(500(859)(746))))))(553(485(71)(463))(99(281)(522(921(683(516(461)(233))(978(908)(702)))(550))(47(364(982(725)(183))(905(14)(340)))(717))))))(520(285(761)(249(827)(526)))(723(918(371(236(158(831(846)(376))(457))(301))(150(542)(428(68(639)(471))(58(948)(370)))))(748))(811(807(284)(433(905)(870)))(517(861)(334(621)(241))))))) +(238(539(118(169(357(407(684)(763(960)(830(201)(670))))(150(34)(592(628(34)(637))(856(801)(263)))))(769(412(827(41(203)(401))(633(308)(456)))(36))(964)))(668(158)(365(60)(57))))(814(492(496)(991(669)(2(7(92(369)(446))(30(749)(636)))(732(745)(825(188)(927))))))(468(453(535(594)(918(622(444)(977))(970(912)(542))))(802))(301(993)(106(416(81(627)(262))(325(512)(341)))(570(402)(611(61)(443))))))))(837(258(572(790)(868))(369(153)(353(496(100(656)(928(951)(670)))(895))(284(447(981)(178))(815(738(46)(329))(316(533)(400)))))))(444(214)(608(972(493)(888(261(945(106)(362))(7))(541(822)(169(743)(852)))))(585(326)(986(411(863(623)(543))(406))(786(1(63)(161))(380(555)(700))))))))) +(671(793(527(312(836)(718(695(194)(835(728)(229(397(357)(551))(492(215)(707)))))(540(9(30)(333(543(393)(966))(842(319)(355))))(328(218)(830)))))(721(779)(410(234)(792(885)(268)))))(104(853)(120(439)(544))))(56(119(489(636(610(319)(963(970(490)(905))(657)))(498))(738))(138(147(514(288(913(358(868)(993))(106(753)(200)))(502(34(253)(667))(901(472)(257))))(373(191(927(249)(960))(769(976)(650)))(995(929(142)(156))(6))))(968(322(115(616)(670(469)(795)))(692))(327(892(967(882)(952))(102(796)(489)))(21(2(720)(425))(907(436)(994))))))(998(405(183(477(640(381)(485))(238(263)(417)))(490(207(900)(880))(959)))(350(707)(839(834)(350(164)(213)))))(899(401(520(759(658)(295))(952(568)(862)))(487(17(474)(87))(40)))(692)))))(594(632(489)(296))(597(233(589(461)(473(735(490)(17(566)(720)))(527(767(322)(719))(308(895)(138)))))(730))(37))))) +(33(822(142(902(619)(919(27(798(998(535)(995))(711(121)(302)))(173))(752(490)(820(139(529)(643))(780(402)(231))))))(122))(17(627(830(744)(581(387(417(758)(582))(579(522)(5)))(818(815)(351(510)(757)))))(687))(824)))(186(104(350(263(319(601(366(6)(213))(651))(328(211)(28)))(198(603)(846)))(629))(808(164)(750(461(945(968(230)(519))(1))(951))(492(939(811(611)(392))(559(952)(719)))(743(675(51)(595))(411(282)(300)))))))(724(840(440)(840(638(689(20(523)(193))(258(999)(221)))(629))(675(513)(856(904(650)(986))(564)))))(588(95)(396(476)(37(424(804(772)(698))(86(719)(158)))(96))))))) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/Baumalgorithmen.java b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/Baumalgorithmen.java new file mode 100644 index 0000000..896223e --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/Baumalgorithmen.java @@ -0,0 +1,130 @@ + +/** + * Führt verschiedene Algorithmen auf Binärbäumen aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Baumalgorithmen +{ + /** + * Die Wurzel des Baums, mit dem der Algorithmus durchgeführt werden soll + */ + protected Binaerbaum wurzel; + + /** + * Erzeugt ein neues Algorithmen-Objekt + * @param wurzel Die Wurzel des Baums, der verarbeitet werden soll + */ + public Baumalgorithmen(Binaerbaum wurzel) + { + this.wurzel = wurzel; + } + + /** + * Zeigt den Baum auf der Konsole an. + */ + public void baumAnzeigen() + { + if (wurzel != null) + { + System.out.println(wurzel.daten); + baumAnzeigen(wurzel.links, "", true); + baumAnzeigen(wurzel.rechts, "", false); + } + } + + private void baumAnzeigen(Binaerbaum b, String indent, boolean left) + { + System.out.print(indent); + System.out.print(left ? "\u251C " : "\u2514 "); + if (b != null) + { + System.out.println(b.daten); + if (b.links != null || b.rechts != null) + { + indent += (left ? "\u2502 " : " "); + baumAnzeigen(b.links, indent, true); + baumAnzeigen(b.rechts, indent, false); + } + } + else + { + System.out.println(""); + } + } + + /** + * Gibt die Tiefe des Baums zurück + * @return Die Tiefe des Baums, gezählt ab der Wurzel + */ + public int tiefe() + { + return tiefe(wurzel); + } + + /** + * Gibt die Tiefe eines Baums zurück + * @param b Der Baum, dessen Tiefe bestimmt werden soll + * @return Die Tiefe des Baums, gezählt ab b + */ + private int tiefe(Binaerbaum b) + { + if (b == null) + { + return 0; + } + return 1 + Math.max(tiefe(b.links), tiefe(b.rechts)); + } + + /** + * Gibt die Anzahl der Knoten im Baums zurück + * @return Die Anzahl aller Knoten im Baum + */ + public int anzahl() + { + return anzahl(wurzel); + } + + /** + * Gibt die Anzahl der Knoten in einem Baums zurück + * @param b Der Baum, in dem die Knoten gezählt werden sollen + * @return Die Anzahl der Knoten, die sich von b an im Baum befinden (inklusive b) + */ + private int anzahl(Binaerbaum b) + { + if (b == null) + { + return 0; + } + return 1 + anzahl(b.links) + anzahl(b.rechts); + } + + /** + * Prüft, ob sich ein Wert im Baum befindet + * @param wert Der zu suchende Wert + * @return true, wenn ein Knoten den Wert enthält; false sonst + */ + public boolean enthaelt(T wert) + { + return enthaelt(wurzel, wert); + } + + /** + * Prüft, ob sich ein Wert in b oder darunter befindet + * @param b Der Baum, in dem der Wert gesucht werden soll + * @return true, wenn b oder einer seiner Kindknoten den Wert enthält; false sonst + */ + private boolean enthaelt(Binaerbaum b, T wert) + { + if (b == null) + { + return false; + } + if (b.daten.equals(wert)) + { + return true; + } + return enthaelt(b.links, wert) || enthaelt(b.rechts, wert); + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/Binaerbaum.java b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/README.TXT b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/README.TXT new file mode 100644 index 0000000..2e30d29 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/README.TXT @@ -0,0 +1,9 @@ +PROJEKTBEZEICHNUNG: Tiefer Baum +PROJEKTZWECK: Erzeugt einen tiefen Baum, auf den man rekursive Baumalgorithmen anwenden kann. Ab einer gewissen Baumtiefe (ca. 30.000; maschinenabhängig) kommt es zum Stack Overflow. +VERSION oder DATUM: Dezember 2020 +WIE IST DAS PROJEKT ZU STARTEN: +Rufen Sie die statische Methode erzeugeTiefenBaum der Klasse TieferBaum auf (Parameter tiefe > 30.000) und holen Sie sich das Objekt auf die Objektleiste +Erzeugen Sie ein Baumalgorithmen-Objekt und übergeben Sie ihm den erzeugten tiefen Baum. +Rufen Sie bei diesem Objekt eine der öffentlichen Methoden auf. +Es sollte ein Stack Overflow entstehen, wenn der Baum nur tief genug ist. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/TieferBaum.java b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/TieferBaum.java new file mode 100644 index 0000000..fac1f4d --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/TieferBaum.java @@ -0,0 +1,30 @@ +import java.util.Random; + +/** + * Erzeugt einen "tiefen" Baum + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class TieferBaum +{ + /** + * Erzeugt einen "tiefen" Baum, bei dem nach rechts stets nur ein Knoten abgeht, + * der links aber eine lange Kette bildet + * @param tiefe Die gewünschte Tiefe + * @return Die Wurzel des erzeugten Binärbaums + */ + public static Binaerbaum erzeugeTiefenBaum(int tiefe) + { + Random r = new Random(); + Binaerbaum wurzel = new Binaerbaum(r.nextInt(1000)); + Binaerbaum k = wurzel; + for (int i = 1; i < tiefe; i++) + { + k.links = new Binaerbaum(r.nextInt(1000)); + k.rechts = new Binaerbaum(r.nextInt(1000)); + k = k.links; + } + return wurzel; + } +} diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/package.bluej b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/package.bluej new file mode 100644 index 0000000..b6c7523 --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/04_tiefer_baum_roh/package.bluej @@ -0,0 +1,52 @@ +#BlueJ package file +dependency1.from=TieferBaum +dependency1.to=Binaerbaum +dependency1.type=UsesDependency +dependency2.from=Baumalgorithmen +dependency2.to=Binaerbaum +dependency2.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1071 +editor.fx.0.x=756 +editor.fx.0.y=182 +objectbench.height=155 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.73 +package.editor.height=431 +package.editor.width=649 +package.editor.x=541 +package.editor.y=197 +package.frame.height=700 +package.frame.width=800 +package.numDependencies=2 +package.numTargets=3 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Binaerbaum +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=170 +target1.y=60 +target2.height=50 +target2.name=Baumalgorithmen +target2.showInterface=false +target2.type=ClassTarget +target2.width=160 +target2.x=300 +target2.y=130 +target3.height=50 +target3.name=TieferBaum +target3.showInterface=false +target3.type=ClassTarget +target3.width=100 +target3.x=101 +target3.y=182 diff --git a/Quellcodes/Alg_DS_Baumalgorithmen/readme.adoc b/Quellcodes/Alg_DS_Baumalgorithmen/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Baumalgorithmen/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/.gitignore b/Quellcodes/Alg_DS_Entscheidungsbaum/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/Binaerbaum.java b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/Binaerbaum.java new file mode 100644 index 0000000..312231d --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/Binaerbaum.java @@ -0,0 +1,11 @@ + +/** + * Ihre Implementation eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + +} diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/EntscheidungsFrame.java b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/EntscheidungsFrame.java new file mode 100644 index 0000000..18dc6c5 --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/EntscheidungsFrame.java @@ -0,0 +1,73 @@ + +/** + * Stellt das Fenster dar, in dem der Baum dargestellt wird. + * Sie müssen die abstrakten Methoden der Oberklasse mit Inhalt füllen. + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class EntscheidungsFrame extends EntscheidungsFrameBase +{ + /** + * Der Entscheidungsbaum, der durchlaufen werden soll. + */ + private Binaerbaum baum; + + /** + * Erzeugt ein neues Fenster + * @param baum Der Entscheidungsbaum, der durchlaufen werden soll + */ + private EntscheidungsFrame(Binaerbaum baum) + { + this.baum = baum; + displayCurrent(); + } + + /** + * Erzeugt einen Entscheidungsbaum und übergibt ihn an ein Fenster + * Dann wird das Fenster geöffnet + */ + public static void entscheidungsbaumTesten() + { + Binaerbaum meinBaum = null; + //# Hier muss meinBaum auf einen Entscheidungsbaum gesetzt werden + + + //# der folgende Aufruf muss stehen bleiben + new EntscheidungsFrame(meinBaum); + } + + /** + * Wird ausgeführt, wenn der Benutzer auf "Ja" klickt. + * Setzt den aktuellen Knoten des Entscheidungsbaums entsprechend weiter. + */ + protected void jaGeklickt() + { + } + + /** + * Wird ausgeführt, wenn der Benutzer auf "Nein" klickt. + * Setzt den aktuellen Knoten des Entscheidungsbaums entsprechend weiter. + */ + protected void neinGeklickt() + { + } + + /** + * Prüft, ob der aktuelle Knoten ein Blattknoten ist und wir damit bei einer Lösung angekommen sind. + * @return true, wenn es sich beim aktuellen Knoten um einen Blattknoten handelt; false sonst + */ + protected boolean istLoesung() + { + return true; + } + + /** + * Gibt den Wert des momentan ausgewählten Knotens im Entscheidungsbaum zurück + * @return Die Beschreibung am aktuellen Knoten + */ + protected String aktuellerText() + { + return ""; + } +} diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/EntscheidungsFrameBase.java b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/EntscheidungsFrameBase.java new file mode 100644 index 0000000..3fc7ea7 --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/EntscheidungsFrameBase.java @@ -0,0 +1,94 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; + +/** + * Das Fenster, in dem der Entscheidungsbaum durchlaufen wird + * Hier sollte nichts geändert werden. + * + * @version 1.0 vom 26.10.2020 + * @author Rainer Helfrich + */ + +public abstract class EntscheidungsFrameBase extends JFrame { + + private JTextArea jTextArea1 = new JTextArea(""); + private JScrollPane jTextArea1ScrollPane = new JScrollPane(jTextArea1); + private JButton bJa = new JButton(); + private JButton bNein = new JButton(); + + + public EntscheidungsFrameBase() + { + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 537; + int frameHeight = 312; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Entscheidungsbaum"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + + jTextArea1ScrollPane.setBounds(8, 8, 505, 217); + jTextArea1.setEditable(false); + cp.add(jTextArea1ScrollPane); + bJa.setBounds(8, 232, 249, 33); + bJa.setText("Ja"); + bJa.setMargin(new Insets(2, 2, 2, 2)); + bJa.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + jaGeklickt(); + displayCurrent(); + } + }); + cp.add(bJa); + bNein.setBounds(264, 232, 249, 33); + bNein.setText("Nein"); + bNein.setMargin(new Insets(2, 2, 2, 2)); + bNein.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + neinGeklickt(); + displayCurrent(); + } + }); + cp.add(bNein); + + setVisible(true); + } + + protected void displayCurrent() + { + jTextArea1.setText(aktuellerText()); + bJa.setEnabled(!istLoesung()); + bNein.setEnabled(!istLoesung()); + } + + /** + * Gibt den Wert des momentan ausgewählten Knotens im Entscheidungsbaum zurück + * @return Die Beschreibung am aktuellen Knoten + */ + protected abstract String aktuellerText(); + + /** + * Wird ausgeführt, wenn der Benutzer auf "Ja" klickt. + * Setzt den aktuellen Knoten des Entscheidungsbaums entsprechend weiter. + */ + protected abstract void jaGeklickt(); + + /** + * Wird ausgeführt, wenn der Benutzer auf "Nein" klickt. + * Setzt den aktuellen Knoten des Entscheidungsbaums entsprechend weiter. + */ + protected abstract void neinGeklickt(); + + /** + * Prüft, ob der aktuelle Knoten ein Blattknoten ist und wir damit bei einer Lösung angekommen sind. + * @return true, wenn es sich beim aktuellen Knoten um einen Blattknoten handelt; false sonst + */ + protected abstract boolean istLoesung(); +} diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/Entscheidungsbaum.pdf b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/Entscheidungsbaum.pdf new file mode 100644 index 0000000..b99afc9 Binary files /dev/null and b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/Entscheidungsbaum.pdf differ diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/README.TXT b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/README.TXT new file mode 100644 index 0000000..a53c383 --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Entscheidungsbaum +PROJEKTZWECK: Implementieren Sie einen Binärbaum und wenden Sie ihn an, um einen Entscheidungsbaum zu implementieren +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Rufen Sie die statische Methode entscheidungsbaumTesten() der Klasse EntscheidungsFrame auf. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/package.bluej b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/package.bluej new file mode 100644 index 0000000..1dcd4d9 --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/01_entscheidungsbaum_roh/package.bluej @@ -0,0 +1,49 @@ +#BlueJ package file +dependency1.from=EntscheidungsFrame +dependency1.to=Binaerbaum +dependency1.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +objectbench.height=93 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8 +package.editor.height=393 +package.editor.width=649 +package.editor.x=329 +package.editor.y=161 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=1 +package.numTargets=3 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Binaerbaum +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=240 +target1.y=170 +target2.height=50 +target2.name=EntscheidungsFrame +target2.showInterface=false +target2.type=ClassTarget +target2.width=150 +target2.x=380 +target2.y=30 +target3.height=50 +target3.name=EntscheidungsFrameBase +target3.showInterface=false +target3.type=AbstractTarget +target3.width=180 +target3.x=110 +target3.y=30 diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/Binaerbaum.java b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/EntscheidungsFrame.java b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/EntscheidungsFrame.java new file mode 100644 index 0000000..f4d6742 Binary files /dev/null and b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/EntscheidungsFrame.java differ diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/EntscheidungsFrameBase.java b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/EntscheidungsFrameBase.java new file mode 100644 index 0000000..d4f9e7f --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/EntscheidungsFrameBase.java @@ -0,0 +1,94 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; + +/** + * Das Fenster, in dem der Entscheidungsbaum durchlaufen wird + * Hier sollte nichts geändert werden. + * + * @version 1.0 vom 26.10.2020 + * @author Rainer Helfrich + */ + +public abstract class EntscheidungsFrameBase extends JFrame { + + private JTextArea jTextArea1 = new JTextArea(""); + private JScrollPane jTextArea1ScrollPane = new JScrollPane(jTextArea1); + private JButton bJa = new JButton(); + private JButton bNein = new JButton(); + + + public EntscheidungsFrameBase() + { + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 537; + int frameHeight = 312; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Entscheidungsbaum"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + + jTextArea1ScrollPane.setBounds(8, 8, 505, 217); + jTextArea1.setEditable(false); + cp.add(jTextArea1ScrollPane); + bJa.setBounds(8, 232, 249, 33); + bJa.setText("Ja"); + bJa.setMargin(new Insets(2, 2, 2, 2)); + bJa.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + jaGeklickt(); + displayCurrent(); + } + }); + cp.add(bJa); + bNein.setBounds(264, 232, 249, 33); + bNein.setText("Nein"); + bNein.setMargin(new Insets(2, 2, 2, 2)); + bNein.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + neinGeklickt(); + displayCurrent(); + } + }); + cp.add(bNein); + + setVisible(true); + } + + protected void displayCurrent() + { + jTextArea1.setText(aktuellerText()); + bJa.setEnabled(!istLoesung()); + bNein.setEnabled(!istLoesung()); + } + + /** + * Gibt den Wert des momentan ausgew�hlten Knotens im Entscheidungsbaum zur�ck + * @return Die Beschreibung am aktuellen Knoten + */ + protected abstract String aktuellerText(); + + /** + * Wird ausgef�hrt, wenn der Benutzer auf "Ja" klickt. + * Setzt den aktuellen Knoten des Entscheidungsbaums entsprechend weiter. + */ + protected abstract void jaGeklickt(); + + /** + * Wird ausgef�hrt, wenn der Benutzer auf "Nein" klickt. + * Setzt den aktuellen Knoten des Entscheidungsbaums entsprechend weiter. + */ + protected abstract void neinGeklickt(); + + /** + * Pr�ft, ob der aktuelle Knoten ein Blattknoten ist und wir damit bei einer L�sung angekommen sind. + * @return true, wenn es sich beim aktuellen Knoten um einen Blattknoten handelt; false sonst + */ + protected abstract boolean istLoesung(); +} diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/README.TXT b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/README.TXT new file mode 100644 index 0000000..a53c383 --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Entscheidungsbaum +PROJEKTZWECK: Implementieren Sie einen Binärbaum und wenden Sie ihn an, um einen Entscheidungsbaum zu implementieren +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Rufen Sie die statische Methode entscheidungsbaumTesten() der Klasse EntscheidungsFrame auf. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/package.bluej b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/package.bluej new file mode 100644 index 0000000..a27f769 --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/02_entscheidungsbaum_loes/package.bluej @@ -0,0 +1,49 @@ +#BlueJ package file +dependency1.from=EntscheidungsFrame +dependency1.to=Binaerbaum +dependency1.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +objectbench.height=93 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8 +package.editor.height=393 +package.editor.width=649 +package.editor.x=329 +package.editor.y=161 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=1 +package.numTargets=3 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Binaerbaum +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=290 +target1.y=150 +target2.height=50 +target2.name=EntscheidungsFrame +target2.showInterface=false +target2.type=ClassTarget +target2.width=150 +target2.x=380 +target2.y=30 +target3.height=50 +target3.name=EntscheidungsFrameBase +target3.showInterface=false +target3.type=AbstractTarget +target3.width=180 +target3.x=110 +target3.y=30 diff --git a/Quellcodes/Alg_DS_Entscheidungsbaum/readme.adoc b/Quellcodes/Alg_DS_Entscheidungsbaum/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Entscheidungsbaum/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Freecell/.gitignore b/Quellcodes/Alg_DS_Freecell/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/FreecellFrame.java b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/FreecellFrame.java new file mode 100644 index 0000000..797e280 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/FreecellFrame.java @@ -0,0 +1,257 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import javax.imageio.ImageIO; +import java.util.*; + +/** + * Das Fenster, in dem das Freecell-Spiel dargestellt wird. + * Hier sollte nichts verändert werden. + * + * @version 10.10.2020 + * @author Rainer Helfrich + */ +public class FreecellFrame extends JFrame { + + public FreecellFrame(FreecellGame g) { + // Frame-Initialisierung + super(); + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 8*Karte.CARD_WIDTH+150; + int frameHeight = 640+2*Karte.CARD_HEIGHT; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Freecell"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + // Anfang Komponenten + + JPanel jPanel1 = new FreecellPanel(g); + jPanel1.setBounds(0, 0, frameWidth, frameHeight); + jPanel1.setOpaque(true); + cp.add(jPanel1); + // Ende Komponenten + + setVisible(true); + } // end of public FreecellFrame + + + + // Ende Methoden + private class FreecellPanel extends JPanel implements MouseListener{ + + FreecellGame dasSpiel; + + public FreecellPanel(FreecellGame g) + { + super( null, true); + dasSpiel = g; + this.addMouseListener(this); + markiert = null; + sourceArea = -1; + sourceIndex = -1; + } + + public void paint(Graphics g) { + g.setColor(new Color(0, 100, 0)); + g.fillRect(0,0,getWidth(),getHeight()); + for (int i = 0; i < 4; i++) { + Karte k = dasSpiel.getKarte(FreecellGame.ZELLEN, i); + if (k == null) + { + g.setColor(new Color(0, 80, 0)); + g.fillRoundRect(10+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + g.setColor(Color.BLACK); + g.drawRoundRect(10+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + } // end of if + else + { + k.zeichne(g, 10+(Karte.CARD_WIDTH+10)*i, 20); + } + } // end of for + for (int i = 0; i < 4; i++) + { + Karte k = dasSpiel.getKarte(FreecellGame.ABLAGESTAPEL, i); + if (k == null) + { + g.setColor(new Color(0, 80, 0)); + g.fillRoundRect(4*Karte.CARD_WIDTH+90+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + g.setColor(Color.BLACK); + g.drawRoundRect(4*Karte.CARD_WIDTH+90+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + } // end of if + else + { + k.zeichne(g, 4*Karte.CARD_WIDTH+90+(Karte.CARD_WIDTH+10)*i, 20); + } + } // end of for + for (int i = 0; i < 8; i++) { + int hoehe = dasSpiel.getStapelHoehe(i); + for (int j = 0; j < hoehe; j++) + { + Karte k = dasSpiel.getKarteInStapel(i, hoehe-1-j); + k.zeichne(g, 35+(Karte.CARD_WIDTH+10)*i, Karte.CARD_HEIGHT+55+j*30); + } + } // end of for + } + + Karte markiert; + int sourceArea; + int sourceIndex; + + public void mouseExited(MouseEvent e) { + } + + public void mouseClicked(MouseEvent e) { + if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) + { + int area = getArea(e.getPoint()); + if (area == FreecellGame.ABLAGESTAPEL) + { + return; + } + int index = getIndex(e.getPoint(), area); + if (index == FreecellGame.KEINER) + { + return; + } + + if (dasSpiel.schnellerZug(area, index)) + { + if (markiert != null) + { + markiert.setMarkiert(false); + markiert = null; + } + finishMove(); + } + } + } + + public void mouseEntered(MouseEvent e){ + } + + public void mousePressed(MouseEvent e){ + } + + + private int getArea(Point p) + { + if (p.getY() >= 20 && p.getY() <= Karte.CARD_HEIGHT+20) + { + if (p.getX() >= 10 && p.getX() <= Karte.CARD_WIDTH*4+40) + { + return FreecellGame.ZELLEN; + } // end of if + if (p.getX() >= Karte.CARD_WIDTH*4+90 && p.getY() <= Karte.CARD_WIDTH*8+120) + { + return FreecellGame.ABLAGESTAPEL; + } // end of if + } // end of if + if (p.getY() >= Karte.CARD_HEIGHT+55 && p.getX() >= 35 && p.getX() <= Karte.CARD_WIDTH*8+105) + { + return FreecellGame.KASKADEN; + } + return FreecellGame.KEINER; + } + + private int getIndex(Point p, int area) + { + if (area < 0) + { + return FreecellGame.KEINER; + } + int x = (int)p.getX(); + if (area == FreecellGame.ZELLEN) + { + x -= 10; + } // end of if + if (area == FreecellGame.ABLAGESTAPEL) + { + x -= 4*Karte.CARD_WIDTH+90; + } // end of if + if (area == FreecellGame.KASKADEN) + { + x -= 35; + } // end of if + if (x % (Karte.CARD_WIDTH+10) < Karte.CARD_WIDTH) + { + return x / (Karte.CARD_WIDTH+10); + } // end of if + return FreecellGame.KEINER; + } + + public void mouseReleased(MouseEvent e) + { + int area = getArea(e.getPoint()); + int index = getIndex(e.getPoint(), area); + if (area == FreecellGame.KEINER || index == FreecellGame.KEINER) { + if (markiert != null) + markiert.setMarkiert(false); + markiert = null; + } // end of if + else if (markiert == null) + { + if (area == FreecellGame.ZELLEN || area == FreecellGame.KASKADEN) + { + markiert = dasSpiel.getKarte(area, index); + } + if (markiert != null) + { + markiert.setMarkiert(true); + sourceArea = area; + sourceIndex = index; + } // end of if + } + else + { + if (sourceArea == area && sourceIndex == index || + dasSpiel.verschiebe(sourceArea, sourceIndex, area, index)) + { + markiert.setMarkiert(false); + markiert = null; + } + } + finishMove(); + } + + private void finishMove() + { + if (markiert != null) + { + repaint(); + return; + } + while(true) + { + paintImmediately(0, 0, getWidth(), getHeight()); + if (dasSpiel.automatischerZug()) + { + try + { + Thread.sleep(300); + } + catch(Exception x) + { + } + } + else + { + break; + } + } + if (dasSpiel.istGewonnen()) + { + JOptionPane.showMessageDialog(null,"Gewonnen!","Spiel beendet", JOptionPane.INFORMATION_MESSAGE); + } + } + + } +} // end of class FreecellFrame diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/FreecellGame.java b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/FreecellGame.java new file mode 100644 index 0000000..f62e830 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/FreecellGame.java @@ -0,0 +1,191 @@ +import java.util.ArrayList; +import java.util.Random; + +/** + * Das Spielfeld selbst + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class FreecellGame +{ + /** + * Die vier Zellen oben links + */ + private Karte[] zellen; + + /** + * Die vier Stapel oben rechts + */ + private Stack[] ablagestapel; + + /** + * Die acht Stapel unten, auf denen die Karten zu Beginn liegen + */ + private Stack[] kaskaden; + + /** + * Konstanten, die für die verschiedenen Ablegebereiche stehen. + */ + public static final int ZELLEN = 0; + public static final int ABLAGESTAPEL = 1; + public static final int KASKADEN = 2; + public static final int KEINER = -1; + + /** + * Erzeugt ein neues Spiel mit einer zufälligen Ausgangssituation. + */ + public FreecellGame() + { + this(new Random()); + } + + /** + * Erzeugt ein neues Spiel mit einer vorgegebenen Nummer. + * Ein Spiel mit einer bestimmten Nummer beginnt immer in der gleichen Ausgangssituation. + * @param nummer Legt fest, welche Ausgangssituation verwendet wird. + */ + public FreecellGame(int nummer) + { + this(new Random(nummer)); + } + + /** + * Erzeugt ein neues Spiel + * @param r Der Zufallsgenerator, der zum zufälligen Füllen der Kaskaden verwendet wird. + */ + private FreecellGame(Random r) + { + zellen = new Karte[4]; + ablagestapel = new Stack[4]; + kaskaden = new Stack[8]; + ArrayList zahlen = new ArrayList(52); + for (int i = 0; i < 52; i++) { + zahlen.add(i); + } + //# TODO: Erzeugen Sie die Stacks für den Ablagestapel und die Kaskaden + + //# Ende TODO + for (int i = 0; i < kaskaden.length; i++) + { + for (int j = 0; j < ((i < 4) ? 7 : 6); j++) { + int rnd = r.nextInt(zahlen.size()); + Karte k = new Karte(zahlen.get(rnd)); + zahlen.remove(rnd); + if (kaskaden[i] != null) + { + kaskaden[i].push(k); + } + } + } + new FreecellFrame(this); + } + + /** + * Gibt die oberste Karte aus dem angegebenen Bereich zurück + * @param bereich Kann ZELLEN, ABLAGESTAPEL oder KASKADEN sein. + * @param index Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (andere Bereiche) sein. Gibt an, welches Feld des Bereichs gewünscht wird. + * @return Die oberste Karte, sofern eine dort liegt. null sonst. + */ + public Karte getKarte(int bereich, int index) + { + //# TODO: Sorgen Sie dafür, dass die (oberste) Karte aus dem gewünschten Bereich zurückgegeben wird. + //# Wenn ein Stapel leer ist, soll null zurückgegeben werden. + + return null; + } + + /** + * Gibt die Höhe der Kaskade mit der gegebenen Nummer zurück + * @param index Kann 0 bis 7 sein. Gibt an, welche Kaskade gewünscht wird. + * @return Die Höhe der Kaskade. + */ + public int getStapelHoehe(int index) + { + //# TODO: Lassen Sie zurückgeben, wie hoch der Stapel der Kaskade mit der Nummer index ist. + + return 0; + } + + /** + * Gibt die n-te Karte von oben in der Kaskade mit der Nummer index zurück. + * Die Parameter sind immer in gültigen Bereichen, wenn die Methode von FreecellFrame aufgerufen wird. + * @param index Kann 0 bis 7 sein. Gibt an, welche Kaskade gewünscht wird. + * @param n Kann 0 bis getStapelHoehe(index)-1 sein. Gibt an, welche Karte darin gewünscht wird. + * @return Die gewünschte Karte + */ + public Karte getKarteInStapel(int index, int n) + { + //# TODO: Lassen Sie die n-te Karte aus der Kaskade mit der Nummer index zurückgeben. + //# n ist dabei von oben gezählt, d.h. die oberste Karte hat den Index 0. + //# n ist immer ein gültiger Index, d.h. die Zahl liegt zwischen 0 und Höhe-1 + + return null; + } + + /** + * Gibt zurück, ob das Spiel gewonnen ist. + * @return true, wenn das Spiel gewonnen ist; false sonst + */ + public boolean istGewonnen() + { + //# TODO: Lassen Sie zurückgeben, ob das Spiel gewonnen ist. + //# Das Spiel ist gewonnen, wenn die Zellen keine Karte enthalten und alle Kaskaden leer sind. + //# Umgekehrt: Falls eine Zelle oder eine Kaskade noch eine Karte enthält, ist das Spiel noch nicht gewonnen. + + return false; + } + + /** + * Verschiebt eine Karte + * @param vonBereich Kann ZELLEN oder KASKADEN sein. Gibt an, aus welchem Bereich die Karte verschoben wird. + * @param vonIndex Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (für Zellen) sein. Gibt an, von welchem Feld des Bereichs die Karte verschoben wird. + * @param nachBereich Kann ZELLEN, ABLAGESTAPEL oder KASKADEN sein. Gibt an, zu welchem Bereich die Karte verschoben wird. + * @param nachIndex Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (andere Bereiche) sein. Gibt an, zu welchem Feld des Bereichs die Karte verschoben wird. + * @return true, wenn die Verschiebung gültig und erfolgreich war; false sonst + */ + public boolean verschiebe(int vonBereich, int vonIndex, int nachBereich, int nachIndex) + { + //# TODO: Verschieben Sie eine Karte. + //# vonBereich kann dabei ZELLEN oder KASKADEN sein, vonIndex ist ein jeweils gültiger Index (0 bis 3 für Zellen, 0 bis 7 für Kaskaden) + //# nachBereich kann ZELLEN, KASKADEN oder ABLAGESTAPEL sein, nachIndex ist ein jeweils gültiger Index + //# Sorgen Sie dafür, dass die Karten an Ihrem Ursprungsort auch entfernt wird! + //# Geben Sie true zurück, wenn die Verschiebung gültig und erfolgreich war, sonst false + + return false; + } + + /** + * Führt einen automatischen Zug aus, wenn dies möglich ist. + * @return true, wenn ein automatischer Zug möglich war; false sonst + */ + public boolean automatischerZug() + { + //# TODO: (optional) Lassen Sie einen automatischen Zug ausführen. + //# Eine Karte kann automatisch von einer Zelle oder einer Kaskade auf einen Ablagestapel gelegt werden, wenn... + //# - sie ein As oder eine 2 ist oder + //# - ihr Wert um höchstens 2 größer ist als die niederwertigste Karte auf allen Ablagestapeln + //# Geben Sie true zurück, wenn ein automatischer Zug möglich war, sonst false. + + return false; + } + + /** + * Führt einen schnellen Zug aus, wenn dies möglich ist. + * @param bereich Kann ZELLEN oder KASKADEN sein. Gibt an, aus welchem Bereich die Karte verschoben wird. + * @param index Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (für Zellen) sein. Gibt an, von welchem Feld des Bereichs die Karte verschoben wird. + * @return true, wenn ein schneller Zug möglich war; false sonst + */ + public boolean schnellerZug(int bereich, int index) + { + //# TODO: (optional) Lassen Sie einen "schnellen Zug" ausführen. "Schnelle Züge" werden durch einen Doppelklick ausgeführt. + //# Ein schneller Zug verschiebt die Karte + //# - von einer Kaskade auf eine freie Zelle oder + //# - von einer Zelle auf einen passenden Ablagestapel + //# bereich kann dabei ZELLEN oder KASKADEN sein, index ist ein jeweils gültiger Index (0 bis 3 für Zellen, 0 bis 7 für Kaskaden) + //# Geben Sie true zurück, wenn ein schneller Zug möglich war, sonst false. + + return false; + } + +} diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/Karte.java b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/Karte.java new file mode 100644 index 0000000..43fe8f8 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/Karte.java @@ -0,0 +1,122 @@ +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import javax.imageio.ImageIO; +import javax.swing.*; +import java.awt.*; + +/** + * Die Klasse Karte repräsentiert eine Karte im Spiel + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Karte +{ + /** + * Konstanten für die vier Kartenfarben + */ + public static final int PIK = 0; + public static final int KREUZ = 1; + public static final int HERZ = 2; + public static final int KARO = 3; + + /** + * Konstanten für die Maße der Karte + */ + public static final int CARD_WIDTH = 100; + public static final int CARD_HEIGHT = 150; + + final private int farbe; + final private int wert; + private BufferedImage image; + private boolean markiert; + + /** + * Erzeugt eine neue Karte + * @param nummer Das als Zahl codierte Bild der Karte + */ + public Karte(int nummer) + { + final String[] suits = { "spades", "clubs", "hearts", "diamonds"}; + farbe = nummer / 13; + wert = nummer % 13 + 1; + markiert = false; + String path = ""; + try + { + path = "img/"+String.format("%02d", wert)+"_of_"+suits[farbe]+".png"; + image = ImageIO.read(new File(path)); + }catch(Exception x){ + System.out.println(path); + System.out.println(x.getMessage()); + } + } + + /** + * Zeichnet die Karte an der Position (x,y) auf das Graphics-Objekt g. + * Sollte nicht direkt aufgerufen werden. + * @param g Das Graphics-Objekt, auf das gezeichnet wird + * @param x Die x-Koordinate der oberen linken Ecke + * @param y Die y-Koordinate der oberen linken Ecke + */ + public void zeichne(Graphics g, int x, int y) + { + if (image != null) { + g.drawImage(image, x, y, CARD_WIDTH, CARD_HEIGHT, null); + } // end of if + else + { + g.setColor(Color.RED); + g.fillRoundRect(x, y, CARD_WIDTH, CARD_HEIGHT, 8, 8); + } + g.setColor(markiert ? Color.BLUE : Color.BLACK); + ((Graphics2D)g).setStroke(new BasicStroke(markiert ? 5 : 1)); + g.drawRoundRect(x, y, CARD_WIDTH, CARD_HEIGHT, 8, 8); + ((Graphics2D)g).setStroke(new BasicStroke(1)); + } + + /** + * Gibt an, ob die Karte vom Spieler markiert (angeklickt) wurde + */ + public boolean getMarkiert() + { + return markiert; + } + + /** + * Setzt die Karte auf markiert/unmarkiert + * @param b true = markiert; false = unmarkiert + */ + public void setMarkiert(boolean b) + { + markiert = b; + } + + /** + * Gibt den Zahlwert der Karte zurück + * @return Der Zahlwert der Karte (1 = As, 2-10, 11 = Bube, 12 = Dame, 13 = König) + */ + public int getWert() + { + return wert; + } + + /** + * Gibt die Farbe der Karte zurück + * @return Einer der Werte PIK, KREUZ, HERZ, KARO + */ + public int getFarbe() + { + return farbe; + } + + /** + * Gibt zurück, ob es sich um eine rote Karte (Herz oder Karo) handelt + * @return true für eine rote Karte, false für eine schwarze + */ + public boolean istRot() + { + return farbe == HERZ || farbe == KARO; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/README.TXT b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/README.TXT new file mode 100644 index 0000000..ec2c86e --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/README.TXT @@ -0,0 +1,8 @@ +PROJEKTBEZEICHNUNG: Freecell +PROJEKTZWECK: Implementieren Sie die Patience Freecell +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ FreecellGame (mit dem int-Parameter kann man steuern, welche Ausgangssituation erzeugt werden soll; lässt man ihn weg, ist die Ausgangssituation zufällig) +AUTOR(EN): Rainer Helfrich, ZPG Informatik + +Quelle der Spielkarten-Bilder: +https://commons.wikimedia.org/wiki/File:English_pattern_playing_cards_deck.svg (Public Domain) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/Stack.java b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/Stack.java new file mode 100644 index 0000000..332c28a --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/Stack.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Stack +{ + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); +} diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_clubs.png new file mode 100644 index 0000000..e27c98b Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_diamonds.png new file mode 100644 index 0000000..1d06f33 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_hearts.png new file mode 100644 index 0000000..63c1e04 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_spades.png new file mode 100644 index 0000000..f977567 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/01_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_clubs.png new file mode 100644 index 0000000..1352718 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_diamonds.png new file mode 100644 index 0000000..2c27525 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_hearts.png new file mode 100644 index 0000000..e615e09 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_spades.png new file mode 100644 index 0000000..6a89abd Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/02_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_clubs.png new file mode 100644 index 0000000..d9b9fee Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_diamonds.png new file mode 100644 index 0000000..58e85f5 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_hearts.png new file mode 100644 index 0000000..609ce36 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_spades.png new file mode 100644 index 0000000..67c08f3 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/03_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_clubs.png new file mode 100644 index 0000000..45e16de Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_diamonds.png new file mode 100644 index 0000000..93caeff Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_hearts.png new file mode 100644 index 0000000..289e42c Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_spades.png new file mode 100644 index 0000000..8c8177a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/04_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_clubs.png new file mode 100644 index 0000000..743e3d5 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_diamonds.png new file mode 100644 index 0000000..6cf0e7a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_hearts.png new file mode 100644 index 0000000..5f28a28 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_spades.png new file mode 100644 index 0000000..e49c8f0 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/05_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_clubs.png new file mode 100644 index 0000000..6a22185 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_diamonds.png new file mode 100644 index 0000000..08f4f6d Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_hearts.png new file mode 100644 index 0000000..5ed84d2 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_spades.png new file mode 100644 index 0000000..2c29e9a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/06_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_clubs.png new file mode 100644 index 0000000..fb7c677 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_diamonds.png new file mode 100644 index 0000000..dbccc3f Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_hearts.png new file mode 100644 index 0000000..ecf7d57 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_spades.png new file mode 100644 index 0000000..1e49b2f Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/07_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_clubs.png new file mode 100644 index 0000000..1bdad87 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_diamonds.png new file mode 100644 index 0000000..baab0ce Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_hearts.png new file mode 100644 index 0000000..d8fcf5d Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_spades.png new file mode 100644 index 0000000..e8b225e Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/08_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_clubs.png new file mode 100644 index 0000000..d2ee501 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_diamonds.png new file mode 100644 index 0000000..33febd3 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_hearts.png new file mode 100644 index 0000000..85fff0a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_spades.png new file mode 100644 index 0000000..7a94875 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/09_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_clubs.png new file mode 100644 index 0000000..ced71e7 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_diamonds.png new file mode 100644 index 0000000..0b096a6 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_hearts.png new file mode 100644 index 0000000..59f2d21 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_spades.png new file mode 100644 index 0000000..345c991 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/10_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_clubs.png new file mode 100644 index 0000000..f2bc216 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_diamonds.png new file mode 100644 index 0000000..d4a6851 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_hearts.png new file mode 100644 index 0000000..2d17ed9 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_spades.png new file mode 100644 index 0000000..95ebf37 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/11_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_clubs.png new file mode 100644 index 0000000..7bd7786 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_diamonds.png new file mode 100644 index 0000000..3f61d10 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_hearts.png new file mode 100644 index 0000000..f8cd494 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_spades.png new file mode 100644 index 0000000..f828390 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/12_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_clubs.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_clubs.png new file mode 100644 index 0000000..2c70d7f Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_diamonds.png new file mode 100644 index 0000000..91d75f4 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_hearts.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_hearts.png new file mode 100644 index 0000000..af869ed Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_spades.png b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_spades.png new file mode 100644 index 0000000..ad6673d Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/13_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/license.txt b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/license.txt new file mode 100644 index 0000000..13adeb0 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/img/license.txt @@ -0,0 +1,3 @@ +Quelle: https://commons.wikimedia.org/wiki/File:English_pattern_playing_cards_deck.svg +Public Domain +Modifikationen von Rainer Helfrich (in Einzelbilder zerlegt) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Freecell/01_freecell_roh/package.bluej b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/package.bluej new file mode 100644 index 0000000..353f688 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/01_freecell_roh/package.bluej @@ -0,0 +1,68 @@ +#BlueJ package file +dependency1.from=FreecellFrame +dependency1.to=FreecellGame +dependency1.type=UsesDependency +dependency2.from=FreecellFrame +dependency2.to=Karte +dependency2.type=UsesDependency +dependency3.from=FreecellGame +dependency3.to=Karte +dependency3.type=UsesDependency +dependency4.from=FreecellGame +dependency4.to=Stack +dependency4.type=UsesDependency +dependency5.from=FreecellGame +dependency5.to=FreecellFrame +dependency5.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +objectbench.height=93 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8 +package.editor.height=393 +package.editor.width=649 +package.editor.x=340 +package.editor.y=126 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=5 +package.numTargets=4 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=FreecellFrame +target1.showInterface=false +target1.type=ClassTarget +target1.width=110 +target1.x=130 +target1.y=20 +target2.height=50 +target2.name=Karte +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=400 +target2.y=90 +target3.height=50 +target3.name=FreecellGame +target3.showInterface=false +target3.type=ClassTarget +target3.width=110 +target3.x=240 +target3.y=190 +target4.height=50 +target4.name=Stack +target4.showInterface=false +target4.type=AbstractTarget +target4.width=80 +target4.x=400 +target4.y=20 diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/ArrayStack.java b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/ArrayStack.java new file mode 100644 index 0000000..dbcc08b --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/ArrayStack.java @@ -0,0 +1,101 @@ + +/** + * Ein Stack basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStack extends Stack +{ + /** + * Enthält die Nutzdaten + */ + private Object[] daten; + /** + * Die Zahl gibt an, wie viele Elemente auf dem Stack liegen und damit auch, + * wie viele Werte im Datenarray gültig sind. + */ + private int anzahl; + + /** + * Erzeugt einen neuen leeren Stack + */ + public ArrayStack() + { + daten = new Object[10]; + anzahl = 0; + } + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + if (!isEmpty()) + { + return (T)daten[anzahl-1]; + } + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + if (!isEmpty()) + { + anzahl--; + return (T)daten[anzahl]; + } + return null; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + if (anzahl == daten.length) + { + Object[] tmp = new Object[2*daten.length]; + System.arraycopy(daten, 0, tmp, 0, daten.length); + daten = tmp; + } + daten[anzahl] = wert; + anzahl++; + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + return anzahl == 0; + } + + /** + * Gibt den Stack in String-Form aus. + * @return Die String-Repräsentation des Stacks + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + b.append("[ "); + for (int i = 0; i < anzahl; i++) + { + if (i > 0) + { + b.append(", "); + } + b.append(daten[i]); + } + b.append(" <"); + return b.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/FreecellFrame.java b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/FreecellFrame.java new file mode 100644 index 0000000..797e280 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/FreecellFrame.java @@ -0,0 +1,257 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import javax.imageio.ImageIO; +import java.util.*; + +/** + * Das Fenster, in dem das Freecell-Spiel dargestellt wird. + * Hier sollte nichts verändert werden. + * + * @version 10.10.2020 + * @author Rainer Helfrich + */ +public class FreecellFrame extends JFrame { + + public FreecellFrame(FreecellGame g) { + // Frame-Initialisierung + super(); + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 8*Karte.CARD_WIDTH+150; + int frameHeight = 640+2*Karte.CARD_HEIGHT; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Freecell"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + // Anfang Komponenten + + JPanel jPanel1 = new FreecellPanel(g); + jPanel1.setBounds(0, 0, frameWidth, frameHeight); + jPanel1.setOpaque(true); + cp.add(jPanel1); + // Ende Komponenten + + setVisible(true); + } // end of public FreecellFrame + + + + // Ende Methoden + private class FreecellPanel extends JPanel implements MouseListener{ + + FreecellGame dasSpiel; + + public FreecellPanel(FreecellGame g) + { + super( null, true); + dasSpiel = g; + this.addMouseListener(this); + markiert = null; + sourceArea = -1; + sourceIndex = -1; + } + + public void paint(Graphics g) { + g.setColor(new Color(0, 100, 0)); + g.fillRect(0,0,getWidth(),getHeight()); + for (int i = 0; i < 4; i++) { + Karte k = dasSpiel.getKarte(FreecellGame.ZELLEN, i); + if (k == null) + { + g.setColor(new Color(0, 80, 0)); + g.fillRoundRect(10+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + g.setColor(Color.BLACK); + g.drawRoundRect(10+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + } // end of if + else + { + k.zeichne(g, 10+(Karte.CARD_WIDTH+10)*i, 20); + } + } // end of for + for (int i = 0; i < 4; i++) + { + Karte k = dasSpiel.getKarte(FreecellGame.ABLAGESTAPEL, i); + if (k == null) + { + g.setColor(new Color(0, 80, 0)); + g.fillRoundRect(4*Karte.CARD_WIDTH+90+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + g.setColor(Color.BLACK); + g.drawRoundRect(4*Karte.CARD_WIDTH+90+(Karte.CARD_WIDTH+10)*i, 20, Karte.CARD_WIDTH, Karte.CARD_HEIGHT, 8, 8); + } // end of if + else + { + k.zeichne(g, 4*Karte.CARD_WIDTH+90+(Karte.CARD_WIDTH+10)*i, 20); + } + } // end of for + for (int i = 0; i < 8; i++) { + int hoehe = dasSpiel.getStapelHoehe(i); + for (int j = 0; j < hoehe; j++) + { + Karte k = dasSpiel.getKarteInStapel(i, hoehe-1-j); + k.zeichne(g, 35+(Karte.CARD_WIDTH+10)*i, Karte.CARD_HEIGHT+55+j*30); + } + } // end of for + } + + Karte markiert; + int sourceArea; + int sourceIndex; + + public void mouseExited(MouseEvent e) { + } + + public void mouseClicked(MouseEvent e) { + if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) + { + int area = getArea(e.getPoint()); + if (area == FreecellGame.ABLAGESTAPEL) + { + return; + } + int index = getIndex(e.getPoint(), area); + if (index == FreecellGame.KEINER) + { + return; + } + + if (dasSpiel.schnellerZug(area, index)) + { + if (markiert != null) + { + markiert.setMarkiert(false); + markiert = null; + } + finishMove(); + } + } + } + + public void mouseEntered(MouseEvent e){ + } + + public void mousePressed(MouseEvent e){ + } + + + private int getArea(Point p) + { + if (p.getY() >= 20 && p.getY() <= Karte.CARD_HEIGHT+20) + { + if (p.getX() >= 10 && p.getX() <= Karte.CARD_WIDTH*4+40) + { + return FreecellGame.ZELLEN; + } // end of if + if (p.getX() >= Karte.CARD_WIDTH*4+90 && p.getY() <= Karte.CARD_WIDTH*8+120) + { + return FreecellGame.ABLAGESTAPEL; + } // end of if + } // end of if + if (p.getY() >= Karte.CARD_HEIGHT+55 && p.getX() >= 35 && p.getX() <= Karte.CARD_WIDTH*8+105) + { + return FreecellGame.KASKADEN; + } + return FreecellGame.KEINER; + } + + private int getIndex(Point p, int area) + { + if (area < 0) + { + return FreecellGame.KEINER; + } + int x = (int)p.getX(); + if (area == FreecellGame.ZELLEN) + { + x -= 10; + } // end of if + if (area == FreecellGame.ABLAGESTAPEL) + { + x -= 4*Karte.CARD_WIDTH+90; + } // end of if + if (area == FreecellGame.KASKADEN) + { + x -= 35; + } // end of if + if (x % (Karte.CARD_WIDTH+10) < Karte.CARD_WIDTH) + { + return x / (Karte.CARD_WIDTH+10); + } // end of if + return FreecellGame.KEINER; + } + + public void mouseReleased(MouseEvent e) + { + int area = getArea(e.getPoint()); + int index = getIndex(e.getPoint(), area); + if (area == FreecellGame.KEINER || index == FreecellGame.KEINER) { + if (markiert != null) + markiert.setMarkiert(false); + markiert = null; + } // end of if + else if (markiert == null) + { + if (area == FreecellGame.ZELLEN || area == FreecellGame.KASKADEN) + { + markiert = dasSpiel.getKarte(area, index); + } + if (markiert != null) + { + markiert.setMarkiert(true); + sourceArea = area; + sourceIndex = index; + } // end of if + } + else + { + if (sourceArea == area && sourceIndex == index || + dasSpiel.verschiebe(sourceArea, sourceIndex, area, index)) + { + markiert.setMarkiert(false); + markiert = null; + } + } + finishMove(); + } + + private void finishMove() + { + if (markiert != null) + { + repaint(); + return; + } + while(true) + { + paintImmediately(0, 0, getWidth(), getHeight()); + if (dasSpiel.automatischerZug()) + { + try + { + Thread.sleep(300); + } + catch(Exception x) + { + } + } + else + { + break; + } + } + if (dasSpiel.istGewonnen()) + { + JOptionPane.showMessageDialog(null,"Gewonnen!","Spiel beendet", JOptionPane.INFORMATION_MESSAGE); + } + } + + } +} // end of class FreecellFrame diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/FreecellGame.java b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/FreecellGame.java new file mode 100644 index 0000000..f3b5ae4 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/FreecellGame.java @@ -0,0 +1,378 @@ +import java.util.ArrayList; +import java.util.Random; + +/** + * Das Spielfeld selbst + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class FreecellGame +{ + /** + * Die vier Zellen oben links + */ + private Karte[] zellen; + + /** + * Die vier Stapel oben rechts + */ + private Stack[] ablagestapel; + + /** + * Die acht Stapel unten, auf denen die Karten zu Beginn liegen + */ + private Stack[] kaskaden; + + /** + * Konstanten, die für die verschiedenen Ablegebereiche stehen. + */ + public static final int ZELLEN = 0; + public static final int ABLAGESTAPEL = 1; + public static final int KASKADEN = 2; + public static final int KEINER = -1; + + /** + * Erzeugt ein neues Spiel mit einer zufälligen Ausgangssituation. + */ + public FreecellGame() + { + this(new Random()); + } + + /** + * Erzeugt ein neues Spiel mit einer vorgegebenen Nummer. + * Ein Spiel mit einer bestimmten Nummer beginnt immer in der gleichen Ausgangssituation. + * @param nummer Legt fest, welche Ausgangssituation verwendet wird. + */ + public FreecellGame(int nummer) + { + this(new Random(nummer)); + } + + /** + * Erzeugt ein neues Spiel + * @param r Der Zufallsgenerator, der zum zufälligen Füllen der Kaskaden verwendet wird. + */ + private FreecellGame(Random r) + { + zellen = new Karte[4]; + ablagestapel = new Stack[4]; + kaskaden = new Stack[8]; + ArrayList zahlen = new ArrayList(52); + for (int i = 0; i < 52; i++) { + zahlen.add(i); + } + //# TODO: Erzeugen Sie die Stacks für den Ablagestapel und die Kaskaden + for (int i = 0; i < ablagestapel.length; i++) { + ablagestapel[i] = new ArrayStack(); + } + for (int i = 0; i < kaskaden.length; i++) { + kaskaden[i] = new ArrayStack(); + } + //# Ende TODO + for (int i = 0; i < kaskaden.length; i++) + { + for (int j = 0; j < ((i < 4) ? 7 : 6); j++) { + int rnd = r.nextInt(zahlen.size()); + Karte k = new Karte(zahlen.get(rnd)); + zahlen.remove(rnd); + if (kaskaden[i] != null) + { + kaskaden[i].push(k); + } + } + } + new FreecellFrame(this); + } + + /** + * Gibt die oberste Karte aus dem angegebenen Bereich zurück + * @param bereich Kann ZELLEN, ABLAGESTAPEL oder KASKADEN sein. + * @param index Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (andere Bereiche) sein. Gibt an, welches Feld des Bereichs gewünscht wird. + * @return Die oberste Karte, sofern eine dort liegt. null sonst. + */ + public Karte getKarte(int bereich, int index) + { + //# TODO: Sorgen Sie dafür, dass die (oberste) Karte aus dem gewünschten Bereich zurückgegeben wird. + //# Wenn ein Stapel leer ist, soll null zurückgegeben werden. + if (bereich == ZELLEN) + { + return zellen[index]; + } + if (bereich == KASKADEN && !kaskaden[index].isEmpty()) + { + return kaskaden[index].top(); + } + if (bereich == ABLAGESTAPEL && !ablagestapel[index].isEmpty()) + { + return ablagestapel[index].top(); + } + return null; + } + + /** + * Gibt die Höhe der Kaskade mit der gegebenen Nummer zurück + * @param index Kann 0 bis 7 sein. Gibt an, welche Kaskade gewünscht wird. + * @return Die Höhe der Kaskade. + */ + public int getStapelHoehe(int index) + { + //# TODO: Lassen Sie zurückgeben, wie hoch der Stapel der Kaskade mit der Nummer index ist. + int size = 0; + Stack temp = new ArrayStack(); + Stack s = kaskaden[index]; + while(!s.isEmpty()) + { + temp.push(s.pop()); + size++; + } + while(!temp.isEmpty()) + { + s.push(temp.pop()); + } + return size; + } + + /** + * Gibt die n-te Karte von oben in der Kaskade mit der Nummer index zurück. + * Die Parameter sind immer in gültigen Bereichen, wenn die Methode von FreecellFrame aufgerufen wird. + * @param index Kann 0 bis 7 sein. Gibt an, welche Kaskade gewünscht wird. + * @param n Kann 0 bis getStapelHoehe(index)-1 sein. Gibt an, welche Karte darin gewünscht wird. + * @return Die gewünschte Karte + */ + public Karte getKarteInStapel(int index, int n) + { + //# TODO: Lassen Sie die n-te Karte aus der Kaskade mit der Nummer index zurückgeben. + //# n ist dabei von oben gezählt, d.h. die oberste Karte hat den Index 0. + //# n ist immer ein gültiger Index, d.h. die Zahl liegt zwischen 0 und Höhe-1 + + Stack temp = new ArrayStack(); + Stack s = kaskaden[index]; + for (int i = 0; i < n; i++) + { + temp.push(s.pop()); + } + Karte k = s.top(); + while(!temp.isEmpty()) + { + s.push(temp.pop()); + } + return k; + } + + /** + * Gibt zurück, ob das Spiel gewonnen ist. + * @return true, wenn das Spiel gewonnen ist; false sonst + */ + public boolean istGewonnen() + { + //# TODO: Lassen Sie zurückgeben, ob das Spiel gewonnen ist. + //# Das Spiel ist gewonnen, wenn die Zellen keine Karte enthalten und alle Kaskaden leer sind. + //# Umgekehrt: Falls eine Zelle oder eine Kaskade noch eine Karte enthält, ist das Spiel noch nicht gewonnen. + for (Karte k : zellen) + { + if (k != null) + { + return false; + } + } + for (Stack s : kaskaden) + { + if (!s.isEmpty()) + { + return false; + } + } + return true; + } + + /** + * Verschiebt eine Karte + * @param vonBereich Kann ZELLEN oder KASKADEN sein. Gibt an, aus welchem Bereich die Karte verschoben wird. + * @param vonIndex Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (für Zellen) sein. Gibt an, von welchem Feld des Bereichs die Karte verschoben wird. + * @param nachBereich Kann ZELLEN, ABLAGESTAPEL oder KASKADEN sein. Gibt an, zu welchem Bereich die Karte verschoben wird. + * @param nachIndex Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (andere Bereiche) sein. Gibt an, zu welchem Feld des Bereichs die Karte verschoben wird. + * @return true, wenn die Verschiebung gültig und erfolgreich war; false sonst + */ + public boolean verschiebe(int vonBereich, int vonIndex, int nachBereich, int nachIndex) + { + //# TODO: Verschieben Sie eine Karte. + //# vonBereich kann dabei ZELLEN oder KASKADEN sein, vonIndex ist ein jeweils gültiger Index (0 bis 3 für Zellen, 0 bis 7 für Kaskaden) + //# nachBereich kann ZELLEN, KASKADEN oder ABLAGESTAPEL sein, nachIndex ist ein jeweils gültiger Index + //# Sorgen Sie dafür, dass die Karten an Ihrem Ursprungsort auch entfernt wird! + //# Geben Sie true zurück, wenn die Verschiebung gültig und erfolgreich war, sonst false + Karte k = null; + if (vonBereich == ZELLEN) + { + k = zellen[vonIndex]; + } + else if (vonBereich == KASKADEN && !kaskaden[vonIndex].isEmpty()) + { + k = kaskaden[vonIndex].top(); + } + else + { + return false; + } + boolean erfolg = false; + if (nachBereich == ZELLEN) + { + erfolg = (zellen[nachIndex] == null); + if (erfolg) + { + zellen[nachIndex] = k; + } + } + if (nachBereich == KASKADEN) + { + if (kaskaden[nachIndex].isEmpty()) + { + erfolg = true; + } + else + { + Karte kk = kaskaden[nachIndex].top(); + erfolg = (kk.getWert() == k.getWert()+1 && kk.istRot() != k.istRot()); + } + if (erfolg) + { + kaskaden[nachIndex].push(k); + } + } + if (nachBereich == ABLAGESTAPEL) + { + if (ablagestapel[nachIndex].isEmpty()) + { + erfolg = (k.getWert() == 1); + } + else + { + Karte kk = ablagestapel[nachIndex].top(); + erfolg = (kk.getFarbe() == k.getFarbe() && kk.getWert() == k.getWert()-1); + } + if (erfolg) + { + ablagestapel[nachIndex].push(k); + } + } + if (erfolg) + { + if (vonBereich == ZELLEN) + { + zellen[vonIndex] = null; + } + else + { + kaskaden[vonIndex].pop(); + } + } + return erfolg; + } + + /** + * Führt einen automatischen Zug aus, wenn dies möglich ist. + * @return true, wenn ein automatischer Zug möglich war; false sonst + */ + public boolean automatischerZug() + { + //# TODO: (optional) Lassen Sie einen automatischen Zug ausführen. + //# Eine Karte kann automatisch von einer Zelle oder einer Kaskade auf einen Ablagestapel gelegt werden, wenn... + //# - sie ein As oder eine 2 ist oder + //# - ihr Wert um höchstens 2 größer ist als die niederwertigste Karte auf allen Ablagestapeln + //# Geben Sie true zurück, wenn ein automatischer Zug möglich war, sonst false. + + int min = 15; + for (Stack s : ablagestapel) + { + if (s.isEmpty()) + { + min = 0; + break; + } + if (s.top().getWert() < min) + { + min = s.top().getWert(); + } + } + for (int i = 0; i < zellen.length; i++) + { + if (zellen[i] != null && zellen[i].getWert() <= min+2 && verschiebeAutomatisch(zellen[i])) + { + zellen[i] = null; + return true; + } + } + for (Stack s : kaskaden) + { + if (!s.isEmpty() && s.top().getWert() <= min+2 && verschiebeAutomatisch(s.top())) + { + s.pop(); + return true; + } + } + return false; + } + + private boolean verschiebeAutomatisch(Karte k) + { + if (k.getWert() == 1) + { + for (Stack s: ablagestapel) + { + if (s.isEmpty()) + { + s.push(k); + return true; + } + } + } + else + { + for (Stack s: ablagestapel) + { + if (!s.isEmpty() && s.top().getFarbe() == k.getFarbe() && s.top().getWert()+1 == k.getWert()) + { + s.push(k); + return true; + } + } + } + return false; + } + + /** + * Führt einen schnellen Zug aus, wenn dies möglich ist. + * @param bereich Kann ZELLEN oder KASKADEN sein. Gibt an, aus welchem Bereich die Karte verschoben wird. + * @param index Kann 0 bis 7 (für Kaskaden) bzw. 0 bis 3 (für Zellen) sein. Gibt an, von welchem Feld des Bereichs die Karte verschoben wird. + * @return true, wenn ein schneller Zug möglich war; false sonst + */ + public boolean schnellerZug(int bereich, int index) + { + //# TODO: (optional) Lassen Sie einen "schnellen Zug" ausführen. "Schnelle Züge" werden durch einen Doppelklick ausgeführt. + //# Ein schneller Zug verschiebt die Karte + //# - von einer Kaskade auf eine freie Zelle oder + //# - von einer Zelle auf einen passenden Ablagestapel + //# bereich kann dabei ZELLEN oder KASKADEN sein, index ist ein jeweils gültiger Index (0 bis 3 für Zellen, 0 bis 7 für Kaskaden) + //# Geben Sie true zurück, wenn ein schneller Zug möglich war, sonst false. + if (bereich == ZELLEN && zellen[index] != null) + { + Karte k = zellen[index]; + zellen[index] = null; + return verschiebeAutomatisch(k); + } + if (bereich == KASKADEN && !kaskaden[index].isEmpty()) + { + for (int i = 0; i < zellen.length; i++) + { + if (zellen[i] == null) + { + zellen[i] = kaskaden[index].pop(); + return true; + } + } + } + return false; + } + +} diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/Karte.java b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/Karte.java new file mode 100644 index 0000000..c34bd63 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/Karte.java @@ -0,0 +1,116 @@ +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import javax.imageio.ImageIO; +import javax.swing.*; +import java.awt.*; + +public class Karte +{ + /** + * Konstanten für die vier Kartenfarben + */ + public static final int PIK = 0; + public static final int KREUZ = 1; + public static final int HERZ = 2; + public static final int KARO = 3; + + /** + * Konstanten für die Maße der Karte + */ + public static final int CARD_WIDTH = 100; + public static final int CARD_HEIGHT = 150; + + final private int farbe; + final private int wert; + private BufferedImage image; + private boolean markiert; + + /** + * Erzeugt eine neue Karte + * @param nummer Das als Zahl codierte Bild der Karte + */ + public Karte(int nummer) + { + final String[] suits = { "spades", "clubs", "hearts", "diamonds"}; + farbe = nummer / 13; + wert = nummer % 13 + 1; + markiert = false; + String path = ""; + try + { + path = "img/"+String.format("%02d", wert)+"_of_"+suits[farbe]+".png"; + image = ImageIO.read(new File(path)); + }catch(Exception x){ + System.out.println(path); + System.out.println(x.getMessage()); + } + } + + /** + * Zeichnet die Karte an der Position (x,y) auf das Graphics-Objekt g. + * Sollte nicht direkt aufgerufen werden. + * @param g Das Graphics-Objekt, auf das gezeichnet wird + * @param x Die x-Koordinate der oberen linken Ecke + * @param y Die y-Koordinate der oberen linken Ecke + */ + public void zeichne(Graphics g, int x, int y) + { + if (image != null) { + g.drawImage(image, x, y, CARD_WIDTH, CARD_HEIGHT, null); + } // end of if + else + { + g.setColor(Color.RED); + g.fillRoundRect(x, y, CARD_WIDTH, CARD_HEIGHT, 8, 8); + } + g.setColor(markiert ? Color.BLUE : Color.BLACK); + ((Graphics2D)g).setStroke(new BasicStroke(markiert ? 5 : 1)); + g.drawRoundRect(x, y, CARD_WIDTH, CARD_HEIGHT, 8, 8); + ((Graphics2D)g).setStroke(new BasicStroke(1)); + } + + /** + * Gibt an, ob die Karte vom Spieler markiert (angeklickt) wurde + */ + public boolean getMarkiert() + { + return markiert; + } + + /** + * Setzt die Karte auf markiert/unmarkiert + * @param b true = markiert; false = unmarkiert + */ + public void setMarkiert(boolean b) + { + markiert = b; + } + + /** + * Gibt den Zahlwert der Karte zurück + * @return Der Zahlwert der Karte (1 = As, 2-10, 11 = Bube, 12 = Dame, 13 = König) + */ + public int getWert() + { + return wert; + } + + /** + * Gibt die Farbe der Karte zurück + * @return Einer der Werte PIK, KREUZ, HERZ, KARO + */ + public int getFarbe() + { + return farbe; + } + + /** + * Gibt zurück, ob es sich um eine rote Karte (Herz oder Karo) handelt + * @return true für eine rote Karte, false für eine schwarze + */ + public boolean istRot() + { + return farbe == HERZ || farbe == KARO; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/README.TXT b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/README.TXT new file mode 100644 index 0000000..ec2c86e --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/README.TXT @@ -0,0 +1,8 @@ +PROJEKTBEZEICHNUNG: Freecell +PROJEKTZWECK: Implementieren Sie die Patience Freecell +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ FreecellGame (mit dem int-Parameter kann man steuern, welche Ausgangssituation erzeugt werden soll; lässt man ihn weg, ist die Ausgangssituation zufällig) +AUTOR(EN): Rainer Helfrich, ZPG Informatik + +Quelle der Spielkarten-Bilder: +https://commons.wikimedia.org/wiki/File:English_pattern_playing_cards_deck.svg (Public Domain) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/Stack.java b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/Stack.java new file mode 100644 index 0000000..332c28a --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/Stack.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Stack +{ + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); +} diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_clubs.png new file mode 100644 index 0000000..e27c98b Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_diamonds.png new file mode 100644 index 0000000..1d06f33 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_hearts.png new file mode 100644 index 0000000..63c1e04 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_spades.png new file mode 100644 index 0000000..f977567 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/01_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_clubs.png new file mode 100644 index 0000000..1352718 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_diamonds.png new file mode 100644 index 0000000..2c27525 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_hearts.png new file mode 100644 index 0000000..e615e09 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_spades.png new file mode 100644 index 0000000..6a89abd Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/02_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_clubs.png new file mode 100644 index 0000000..d9b9fee Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_diamonds.png new file mode 100644 index 0000000..58e85f5 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_hearts.png new file mode 100644 index 0000000..609ce36 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_spades.png new file mode 100644 index 0000000..67c08f3 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/03_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_clubs.png new file mode 100644 index 0000000..45e16de Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_diamonds.png new file mode 100644 index 0000000..93caeff Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_hearts.png new file mode 100644 index 0000000..289e42c Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_spades.png new file mode 100644 index 0000000..8c8177a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/04_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_clubs.png new file mode 100644 index 0000000..743e3d5 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_diamonds.png new file mode 100644 index 0000000..6cf0e7a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_hearts.png new file mode 100644 index 0000000..5f28a28 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_spades.png new file mode 100644 index 0000000..e49c8f0 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/05_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_clubs.png new file mode 100644 index 0000000..6a22185 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_diamonds.png new file mode 100644 index 0000000..08f4f6d Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_hearts.png new file mode 100644 index 0000000..5ed84d2 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_spades.png new file mode 100644 index 0000000..2c29e9a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/06_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_clubs.png new file mode 100644 index 0000000..fb7c677 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_diamonds.png new file mode 100644 index 0000000..dbccc3f Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_hearts.png new file mode 100644 index 0000000..ecf7d57 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_spades.png new file mode 100644 index 0000000..1e49b2f Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/07_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_clubs.png new file mode 100644 index 0000000..1bdad87 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_diamonds.png new file mode 100644 index 0000000..baab0ce Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_hearts.png new file mode 100644 index 0000000..d8fcf5d Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_spades.png new file mode 100644 index 0000000..e8b225e Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/08_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_clubs.png new file mode 100644 index 0000000..d2ee501 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_diamonds.png new file mode 100644 index 0000000..33febd3 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_hearts.png new file mode 100644 index 0000000..85fff0a Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_spades.png new file mode 100644 index 0000000..7a94875 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/09_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_clubs.png new file mode 100644 index 0000000..ced71e7 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_diamonds.png new file mode 100644 index 0000000..0b096a6 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_hearts.png new file mode 100644 index 0000000..59f2d21 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_spades.png new file mode 100644 index 0000000..345c991 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/10_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_clubs.png new file mode 100644 index 0000000..f2bc216 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_diamonds.png new file mode 100644 index 0000000..d4a6851 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_hearts.png new file mode 100644 index 0000000..2d17ed9 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_spades.png new file mode 100644 index 0000000..95ebf37 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/11_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_clubs.png new file mode 100644 index 0000000..7bd7786 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_diamonds.png new file mode 100644 index 0000000..3f61d10 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_hearts.png new file mode 100644 index 0000000..f8cd494 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_spades.png new file mode 100644 index 0000000..f828390 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/12_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_clubs.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_clubs.png new file mode 100644 index 0000000..2c70d7f Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_clubs.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_diamonds.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_diamonds.png new file mode 100644 index 0000000..91d75f4 Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_diamonds.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_hearts.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_hearts.png new file mode 100644 index 0000000..af869ed Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_hearts.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_spades.png b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_spades.png new file mode 100644 index 0000000..ad6673d Binary files /dev/null and b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/13_of_spades.png differ diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/license.txt b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/license.txt new file mode 100644 index 0000000..13adeb0 --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/img/license.txt @@ -0,0 +1,3 @@ +Quelle: https://commons.wikimedia.org/wiki/File:English_pattern_playing_cards_deck.svg +Public Domain +Modifikationen von Rainer Helfrich (in Einzelbilder zerlegt) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Freecell/02_freecell_loes/package.bluej b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/package.bluej new file mode 100644 index 0000000..5fc7ffb --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/02_freecell_loes/package.bluej @@ -0,0 +1,78 @@ +#BlueJ package file +dependency1.from=FreecellFrame +dependency1.to=FreecellGame +dependency1.type=UsesDependency +dependency2.from=FreecellFrame +dependency2.to=Karte +dependency2.type=UsesDependency +dependency3.from=FreecellGame +dependency3.to=Karte +dependency3.type=UsesDependency +dependency4.from=FreecellGame +dependency4.to=Stack +dependency4.type=UsesDependency +dependency5.from=FreecellGame +dependency5.to=ArrayStack +dependency5.type=UsesDependency +dependency6.from=FreecellGame +dependency6.to=FreecellFrame +dependency6.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +objectbench.height=93 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8 +package.editor.height=393 +package.editor.width=649 +package.editor.x=340 +package.editor.y=126 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=6 +package.numTargets=5 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=FreecellFrame +target1.showInterface=false +target1.type=ClassTarget +target1.width=110 +target1.x=110 +target1.y=10 +target2.height=50 +target2.name=Karte +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=10 +target2.y=110 +target3.height=50 +target3.name=ArrayStack +target3.showInterface=false +target3.type=ClassTarget +target3.width=120 +target3.x=420 +target3.y=250 +target4.height=50 +target4.name=FreecellGame +target4.showInterface=false +target4.type=ClassTarget +target4.width=110 +target4.x=210 +target4.y=200 +target5.height=50 +target5.name=Stack +target5.showInterface=false +target5.type=AbstractTarget +target5.width=80 +target5.x=400 +target5.y=20 diff --git a/Quellcodes/Alg_DS_Freecell/readme.adoc b/Quellcodes/Alg_DS_Freecell/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Freecell/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Hanoi/.gitignore b/Quellcodes/Alg_DS_Hanoi/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/HanoiFrame.java b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/HanoiFrame.java new file mode 100644 index 0000000..1aef6c5 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/HanoiFrame.java @@ -0,0 +1,141 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +import java.util.*; + +/** + * Das Fenster, in dem das Hanoi-Spiel dargestellt wird. + * Hier sollte nichts verändert werden. + * + * @version 10.10.2020 + * @author Rainer Helfrich + */ +public class HanoiFrame extends JFrame { + + JPanel jPanel1; + + public HanoiFrame(HanoiGame g) { + // Frame-Initialisierung + super(); + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 900; + int frameHeight = 500; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Türme von Hanoi"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + // Anfang Komponenten + + jPanel1 = new HanoiPanel(g); + jPanel1.setBounds(0, 0, frameWidth, frameHeight); + jPanel1.setOpaque(true); + cp.add(jPanel1); + + // Ende Komponenten + + setVisible(true); + } // end of public FreecellFrame + + + + public void neuZeichnen() + { + jPanel1.paintImmediately(0, 0, getWidth(), getHeight()); + try + { + Thread.sleep(100); + } + catch(Exception x) + { + } + } + // Ende Methoden + private class HanoiPanel extends JPanel implements MouseListener{ + + HanoiGame dasSpiel; + Scheibe markiert; + int fromStack; + + public HanoiPanel(HanoiGame g) + { + super( null, true); + dasSpiel = g; + addMouseListener(this); + markiert = null; + } + + + + public void paint(Graphics g) { + + g.setColor(new Color(180, 180, 180)); + g.fillRect(0,0,getWidth(),getHeight()); + g.setColor(Color.BLACK); + g.fillRect(10, getHeight()-100, 840, 20); + for (int i = 0; i < 3; i++) + { + g.setColor(Color.BLACK); + g.fillRect(145+i*280, 60, 10, getHeight()-160); + int hoehe = dasSpiel.getTurmHoehe(i); + hoehe--; + int baseY = getHeight()-120-20*hoehe; + while(hoehe >= 0) + { + Scheibe s = dasSpiel.getNteScheibe(i, hoehe); + int y = baseY + 20*hoehe; + if (markiert == s) + { + y = 30; + } + s.zeichne(g, 150+280*i, y); + hoehe--; + } + } + } + + public void mouseExited(MouseEvent e) { + } + + public void mouseClicked(MouseEvent e) { + } + + public void mouseEntered(MouseEvent e){ + } + + public void mousePressed(MouseEvent e){ + } + + private int getArea(Point p) + { + return (int)p.getX()/(getWidth()/3); + } + + public void mouseReleased(MouseEvent e) + { + int stack = getArea(e.getPoint()); + if (markiert == null) + { + if (dasSpiel.getTurmHoehe(stack) > 0) + { + markiert = dasSpiel.getNteScheibe(stack, 0); + fromStack = stack; + repaint(); + } + } + else + { + if (fromStack == stack || dasSpiel.bewegeScheibe(fromStack, stack)) + { + markiert = null; + } + repaint(); + } + } + } +} diff --git a/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/HanoiGame.java b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/HanoiGame.java new file mode 100644 index 0000000..013936c --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/HanoiGame.java @@ -0,0 +1,93 @@ +/** + * Das Spielfeld selbst + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class HanoiGame +{ + /** + * Das Array hat drei Elemente und stellt die drei Scheibenstapel dar. + */ + private Stack[] stapel; + + /** + * Verweis auf das Fenster-Objekt. + */ + HanoiFrame derFrame; + + /** + * Erzeugt ein neues Spiel mit 7 Scheiben + */ + public HanoiGame() + { + this(7); + } + + /** + * Erzeugt ein neues Spiel, die Anzahl der Scheiben kann zwischen 1 und 14 liegen. + * @param groesse Die Höhe des Stapels + */ + public HanoiGame(int groesse) + { + if (groesse > 14) + { + groesse = 14; + } + if (groesse < 1) + { + groesse = 1; + } + stapel = new Stack[3]; + //# TODO: Initialisieren Sie die Stacks im Array + + //# Ende TODO + while(stapel[0] != null && groesse > 0) + { + stapel[0].push(new Scheibe(groesse)); + groesse--; + } + derFrame = new HanoiFrame(this); + } + + /** + * Gibt die Höhe des Turms zurück + * @param t Welcher Turm wird abgefragt? 0 = links, 1 = mitte, 2 = rechts + * @return Höhe des gefragten Turmes + */ + public int getTurmHoehe(int t) + { + //# TODO: Geben Sie die Höhe des Stapels mit der Nummer t zurück + + return 0; + } + + /** + * Gibt die n-te Scheibe auf Turm t zurück. n wird von oben gezählt, d.h. n = 0 ist die oberste Scheibe. + * @param t Die Nummer des Turmes (0 = links, 1 = mitte, 2 = rechts) + * @param n Die Nummer der Scheibe (0 <= n < getTurmHoehe(t)) + * @return Die gewünschte Scheibe + */ + public Scheibe getNteScheibe(int t, int n) + { + //# TODO: Geben Sie die n-te Scheibe vom Turm mit der Nummer t zurück + //# n und t sind immer gültige Werte. + + return null; + } + + /** + * Verschiebt eine Scheibe von einem Turm auf den anderen, falls der Zug erlaubt ist + * @param von Die Nummer des Turms (0 = links, 1 = mitte, 2 = rechts), von dem weggezogen wird + * @param nach Die Nummer des Turms (0 = links, 1 = mitte, 2 = rechts), auf den hingezogen wird + * @return true, wenn der Zug erlaubt war; false sonst + */ + public boolean bewegeScheibe(int von, int nach) + { + //# TODO: Verschieben Sie die oberste Scheibe vom Turm "von" auf den Turm "nach" + //# Geben Sie true zurück, wenn die Aktion erlaubt ist + //# Wenn sie nicht erlaubt ist, soll false zurückgegeben werden und nichts verändert werden. + + return false; + } +} diff --git a/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/README.TXT b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/README.TXT new file mode 100644 index 0000000..c475f6d --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Türme von Hanoi +PROJEKTZWECK: Implementieren Sie das Spiel "Die Türme von Hanoi" +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ "HanoiGame" +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/Scheibe.java b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/Scheibe.java new file mode 100644 index 0000000..fcf3fd3 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/Scheibe.java @@ -0,0 +1,55 @@ +import javax.swing.*; +import java.awt.*; + +/** + * Repräsentiert eine Scheibe im Spiel "Die Türme von Hanoi" + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Scheibe +{ + final private Color farbe; + final private int groesse; + + /** + * Erzeugt eine neue Scheibe in der gewünschten Größe. + * Sollte nicht direkt aufgerufen werden! + * @param groesse Die Größe der Scheibe (1 bis 14) + */ + public Scheibe(int groesse) + { + Color[] farben = + { + Color.BLACK, + Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, + Color.CYAN, Color.MAGENTA, Color.ORANGE, Color.PINK, + Color.GRAY, new Color(0x6B8E23), new Color(0x4682B4), new Color(0x9ACD32), + new Color(0xBA55D3), new Color(0x228B22) + }; + this.groesse = groesse; + farbe = farben[groesse]; + } + + /** + * Zeichnet die Scheibe an der Position (x,y) auf das Graphics-Objekt g. + * Sollte nicht direkt aufgerufen werden. + * @param g Das Graphics-Objekt, auf das gezeichnet wird + * @param x Die x-Koordinate der oberen linken Ecke + * @param y Die y-Koordinate der oberen linken Ecke + */ + public void zeichne(Graphics g, int x, int y) + { + g.setColor(farbe); + g.fillRect(x-groesse*10, y, 20*groesse, 15); + } + + /** + * Gibt die Größe der Scheibe zurück + * @return Die Größe der Scheibe (0 bis 14) + */ + public int getGroesse() + { + return groesse; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/Stack.java b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/Stack.java new file mode 100644 index 0000000..332c28a --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/Stack.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Stack +{ + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); +} diff --git a/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/package.bluej b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/package.bluej new file mode 100644 index 0000000..6caa3c6 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/01_hanoi_roh/package.bluej @@ -0,0 +1,68 @@ +#BlueJ package file +dependency1.from=HanoiGame +dependency1.to=HanoiFrame +dependency1.type=UsesDependency +dependency2.from=HanoiGame +dependency2.to=Stack +dependency2.type=UsesDependency +dependency3.from=HanoiGame +dependency3.to=Scheibe +dependency3.type=UsesDependency +dependency4.from=HanoiFrame +dependency4.to=HanoiGame +dependency4.type=UsesDependency +dependency5.from=HanoiFrame +dependency5.to=Scheibe +dependency5.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=816 +editor.fx.0.x=92 +editor.fx.0.y=102 +objectbench.height=183 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.62 +package.editor.height=303 +package.editor.width=649 +package.editor.x=59 +package.editor.y=200 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=5 +package.numTargets=4 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=HanoiGame +target1.showInterface=false +target1.type=ClassTarget +target1.width=110 +target1.x=210 +target1.y=190 +target2.height=50 +target2.name=Scheibe +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=10 +target2.y=110 +target3.height=50 +target3.name=HanoiFrame +target3.showInterface=false +target3.type=ClassTarget +target3.width=110 +target3.x=110 +target3.y=20 +target4.height=50 +target4.name=Stack +target4.showInterface=false +target4.type=AbstractTarget +target4.width=80 +target4.x=400 +target4.y=20 diff --git a/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/ArrayStack.java b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/ArrayStack.java new file mode 100644 index 0000000..dbcc08b --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/ArrayStack.java @@ -0,0 +1,101 @@ + +/** + * Ein Stack basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStack extends Stack +{ + /** + * Enthält die Nutzdaten + */ + private Object[] daten; + /** + * Die Zahl gibt an, wie viele Elemente auf dem Stack liegen und damit auch, + * wie viele Werte im Datenarray gültig sind. + */ + private int anzahl; + + /** + * Erzeugt einen neuen leeren Stack + */ + public ArrayStack() + { + daten = new Object[10]; + anzahl = 0; + } + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + if (!isEmpty()) + { + return (T)daten[anzahl-1]; + } + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + if (!isEmpty()) + { + anzahl--; + return (T)daten[anzahl]; + } + return null; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + if (anzahl == daten.length) + { + Object[] tmp = new Object[2*daten.length]; + System.arraycopy(daten, 0, tmp, 0, daten.length); + daten = tmp; + } + daten[anzahl] = wert; + anzahl++; + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + return anzahl == 0; + } + + /** + * Gibt den Stack in String-Form aus. + * @return Die String-Repräsentation des Stacks + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + b.append("[ "); + for (int i = 0; i < anzahl; i++) + { + if (i > 0) + { + b.append(", "); + } + b.append(daten[i]); + } + b.append(" <"); + return b.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/HanoiFrame.java b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/HanoiFrame.java new file mode 100644 index 0000000..1aef6c5 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/HanoiFrame.java @@ -0,0 +1,141 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +import java.util.*; + +/** + * Das Fenster, in dem das Hanoi-Spiel dargestellt wird. + * Hier sollte nichts verändert werden. + * + * @version 10.10.2020 + * @author Rainer Helfrich + */ +public class HanoiFrame extends JFrame { + + JPanel jPanel1; + + public HanoiFrame(HanoiGame g) { + // Frame-Initialisierung + super(); + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 900; + int frameHeight = 500; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Türme von Hanoi"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + // Anfang Komponenten + + jPanel1 = new HanoiPanel(g); + jPanel1.setBounds(0, 0, frameWidth, frameHeight); + jPanel1.setOpaque(true); + cp.add(jPanel1); + + // Ende Komponenten + + setVisible(true); + } // end of public FreecellFrame + + + + public void neuZeichnen() + { + jPanel1.paintImmediately(0, 0, getWidth(), getHeight()); + try + { + Thread.sleep(100); + } + catch(Exception x) + { + } + } + // Ende Methoden + private class HanoiPanel extends JPanel implements MouseListener{ + + HanoiGame dasSpiel; + Scheibe markiert; + int fromStack; + + public HanoiPanel(HanoiGame g) + { + super( null, true); + dasSpiel = g; + addMouseListener(this); + markiert = null; + } + + + + public void paint(Graphics g) { + + g.setColor(new Color(180, 180, 180)); + g.fillRect(0,0,getWidth(),getHeight()); + g.setColor(Color.BLACK); + g.fillRect(10, getHeight()-100, 840, 20); + for (int i = 0; i < 3; i++) + { + g.setColor(Color.BLACK); + g.fillRect(145+i*280, 60, 10, getHeight()-160); + int hoehe = dasSpiel.getTurmHoehe(i); + hoehe--; + int baseY = getHeight()-120-20*hoehe; + while(hoehe >= 0) + { + Scheibe s = dasSpiel.getNteScheibe(i, hoehe); + int y = baseY + 20*hoehe; + if (markiert == s) + { + y = 30; + } + s.zeichne(g, 150+280*i, y); + hoehe--; + } + } + } + + public void mouseExited(MouseEvent e) { + } + + public void mouseClicked(MouseEvent e) { + } + + public void mouseEntered(MouseEvent e){ + } + + public void mousePressed(MouseEvent e){ + } + + private int getArea(Point p) + { + return (int)p.getX()/(getWidth()/3); + } + + public void mouseReleased(MouseEvent e) + { + int stack = getArea(e.getPoint()); + if (markiert == null) + { + if (dasSpiel.getTurmHoehe(stack) > 0) + { + markiert = dasSpiel.getNteScheibe(stack, 0); + fromStack = stack; + repaint(); + } + } + else + { + if (fromStack == stack || dasSpiel.bewegeScheibe(fromStack, stack)) + { + markiert = null; + } + repaint(); + } + } + } +} diff --git a/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/HanoiGame.java b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/HanoiGame.java new file mode 100644 index 0000000..8d3236f --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/HanoiGame.java @@ -0,0 +1,116 @@ +/** + * Das Spielfeld selbst + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class HanoiGame +{ + /** + * Das Array hat drei Elemente und stellt die drei Scheibenstapel dar. + */ + private Stack[] stapel; + + /** + * Verweis auf das Fenster-Objekt. + */ + HanoiFrame derFrame; + + /** + * Erzeugt ein neues Spiel mit 7 Scheiben + */ + public HanoiGame() + { + this(7); + } + + /** + * Erzeugt ein neues Spiel, die Anzahl der Scheiben kann zwischen 1 und 14 liegen. + * @param groesse Die Höhe des Stapels + */ + public HanoiGame(int groesse) + { + if (groesse > 14) + { + groesse = 14; + } + if (groesse < 1) + { + groesse = 1; + } + stapel = new Stack[3]; + for (int i = 0; i < 3; i++) + { + stapel[i] = new ArrayStack(); + } + while(groesse > 0) + { + stapel[0].push(new Scheibe(groesse)); + groesse--; + } + derFrame = new HanoiFrame(this); + } + + /** + * Gibt die Höhe des Turms zurück + * @param t Welcher Turm wird abgefragt? 0 = links, 1 = mitte, 2 = rechts + * @return Höhe des gefragten Turmes + */ + public int getTurmHoehe(int index) + { + Stack tmp = new ArrayStack(); + int size = 0; + while(!stapel[index].isEmpty()) + { + tmp.push(stapel[index].pop()); + size++; + } + while(!tmp.isEmpty()) + { + stapel[index].push(tmp.pop()); + } + return size; + } + + /** + * Gibt die n-te Scheibe auf Turm t zurück. n wird von oben gezählt, d.h. n = 0 ist die oberste Scheibe. + * @param t Die Nummer des Turmes (0 = links, 1 = mitte, 2 = rechts) + * @param n Die Nummer der Scheibe (0 <= n < getTurmHoehe(t)) + * @return Die gewünschte Scheibe + */ + public Scheibe getNteScheibe(int turm, int index) + { + Stack tmp = new ArrayStack(); + for (int i = 0; i < index; i++) + { + tmp.push(stapel[turm].pop()); + } + Scheibe s = stapel[turm].top(); + while(!tmp.isEmpty()) + { + stapel[turm].push(tmp.pop()); + } + return s; + } + + /** + * Verschiebt eine Scheibe von einem Turm auf den anderen, falls der Zug erlaubt ist + * @param von Die Nummer des Turms (0 = links, 1 = mitte, 2 = rechts), von dem weggezogen wird + * @param nach Die Nummer des Turms (0 = links, 1 = mitte, 2 = rechts), auf den hingezogen wird + * @return true, wenn der Zug erlaubt war; false sonst + */ + public boolean bewegeScheibe(int von, int nach) + { + if (stapel[von].isEmpty()) + { + return false; + } + Scheibe s = stapel[von].top(); + if (stapel[nach].isEmpty() || stapel[nach].top().getGroesse() > s.getGroesse()) + { + stapel[nach].push(stapel[von].pop()); + return true; + } + return false; + } +} diff --git a/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/README.TXT b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/README.TXT new file mode 100644 index 0000000..c475f6d --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Türme von Hanoi +PROJEKTZWECK: Implementieren Sie das Spiel "Die Türme von Hanoi" +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ "HanoiGame" +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/Scheibe.java b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/Scheibe.java new file mode 100644 index 0000000..fcf3fd3 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/Scheibe.java @@ -0,0 +1,55 @@ +import javax.swing.*; +import java.awt.*; + +/** + * Repräsentiert eine Scheibe im Spiel "Die Türme von Hanoi" + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Scheibe +{ + final private Color farbe; + final private int groesse; + + /** + * Erzeugt eine neue Scheibe in der gewünschten Größe. + * Sollte nicht direkt aufgerufen werden! + * @param groesse Die Größe der Scheibe (1 bis 14) + */ + public Scheibe(int groesse) + { + Color[] farben = + { + Color.BLACK, + Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, + Color.CYAN, Color.MAGENTA, Color.ORANGE, Color.PINK, + Color.GRAY, new Color(0x6B8E23), new Color(0x4682B4), new Color(0x9ACD32), + new Color(0xBA55D3), new Color(0x228B22) + }; + this.groesse = groesse; + farbe = farben[groesse]; + } + + /** + * Zeichnet die Scheibe an der Position (x,y) auf das Graphics-Objekt g. + * Sollte nicht direkt aufgerufen werden. + * @param g Das Graphics-Objekt, auf das gezeichnet wird + * @param x Die x-Koordinate der oberen linken Ecke + * @param y Die y-Koordinate der oberen linken Ecke + */ + public void zeichne(Graphics g, int x, int y) + { + g.setColor(farbe); + g.fillRect(x-groesse*10, y, 20*groesse, 15); + } + + /** + * Gibt die Größe der Scheibe zurück + * @return Die Größe der Scheibe (0 bis 14) + */ + public int getGroesse() + { + return groesse; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/Stack.java b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/Stack.java new file mode 100644 index 0000000..332c28a --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/Stack.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Stack +{ + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); +} diff --git a/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/package.bluej b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/package.bluej new file mode 100644 index 0000000..05972e9 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/02_hanoi_loes/package.bluej @@ -0,0 +1,78 @@ +#BlueJ package file +dependency1.from=HanoiFrame +dependency1.to=HanoiGame +dependency1.type=UsesDependency +dependency2.from=HanoiFrame +dependency2.to=Scheibe +dependency2.type=UsesDependency +dependency3.from=HanoiGame +dependency3.to=HanoiFrame +dependency3.type=UsesDependency +dependency4.from=HanoiGame +dependency4.to=Stack +dependency4.type=UsesDependency +dependency5.from=HanoiGame +dependency5.to=ArrayStack +dependency5.type=UsesDependency +dependency6.from=HanoiGame +dependency6.to=Scheibe +dependency6.type=UsesDependency +editor.fx.0.height=763 +editor.fx.0.width=816 +editor.fx.0.x=974 +editor.fx.0.y=70 +objectbench.height=183 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.62 +package.editor.height=303 +package.editor.width=649 +package.editor.x=940 +package.editor.y=268 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=6 +package.numTargets=5 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=HanoiGame +target1.showInterface=false +target1.type=ClassTarget +target1.width=110 +target1.x=210 +target1.y=190 +target2.height=50 +target2.name=Scheibe +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=10 +target2.y=110 +target3.height=50 +target3.name=HanoiFrame +target3.showInterface=false +target3.type=ClassTarget +target3.width=110 +target3.x=110 +target3.y=20 +target4.height=50 +target4.name=ArrayStack +target4.showInterface=false +target4.type=ClassTarget +target4.width=120 +target4.x=380 +target4.y=140 +target5.height=50 +target5.name=Stack +target5.showInterface=false +target5.type=AbstractTarget +target5.width=80 +target5.x=400 +target5.y=20 diff --git a/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/ArrayStack.java b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/ArrayStack.java new file mode 100644 index 0000000..dbcc08b --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/ArrayStack.java @@ -0,0 +1,101 @@ + +/** + * Ein Stack basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStack extends Stack +{ + /** + * Enthält die Nutzdaten + */ + private Object[] daten; + /** + * Die Zahl gibt an, wie viele Elemente auf dem Stack liegen und damit auch, + * wie viele Werte im Datenarray gültig sind. + */ + private int anzahl; + + /** + * Erzeugt einen neuen leeren Stack + */ + public ArrayStack() + { + daten = new Object[10]; + anzahl = 0; + } + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + if (!isEmpty()) + { + return (T)daten[anzahl-1]; + } + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + if (!isEmpty()) + { + anzahl--; + return (T)daten[anzahl]; + } + return null; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + if (anzahl == daten.length) + { + Object[] tmp = new Object[2*daten.length]; + System.arraycopy(daten, 0, tmp, 0, daten.length); + daten = tmp; + } + daten[anzahl] = wert; + anzahl++; + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + return anzahl == 0; + } + + /** + * Gibt den Stack in String-Form aus. + * @return Die String-Repräsentation des Stacks + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + b.append("[ "); + for (int i = 0; i < anzahl; i++) + { + if (i > 0) + { + b.append(", "); + } + b.append(daten[i]); + } + b.append(" <"); + return b.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/HanoiFrame.java b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/HanoiFrame.java new file mode 100644 index 0000000..1aef6c5 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/HanoiFrame.java @@ -0,0 +1,141 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +import java.util.*; + +/** + * Das Fenster, in dem das Hanoi-Spiel dargestellt wird. + * Hier sollte nichts verändert werden. + * + * @version 10.10.2020 + * @author Rainer Helfrich + */ +public class HanoiFrame extends JFrame { + + JPanel jPanel1; + + public HanoiFrame(HanoiGame g) { + // Frame-Initialisierung + super(); + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 900; + int frameHeight = 500; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Türme von Hanoi"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + // Anfang Komponenten + + jPanel1 = new HanoiPanel(g); + jPanel1.setBounds(0, 0, frameWidth, frameHeight); + jPanel1.setOpaque(true); + cp.add(jPanel1); + + // Ende Komponenten + + setVisible(true); + } // end of public FreecellFrame + + + + public void neuZeichnen() + { + jPanel1.paintImmediately(0, 0, getWidth(), getHeight()); + try + { + Thread.sleep(100); + } + catch(Exception x) + { + } + } + // Ende Methoden + private class HanoiPanel extends JPanel implements MouseListener{ + + HanoiGame dasSpiel; + Scheibe markiert; + int fromStack; + + public HanoiPanel(HanoiGame g) + { + super( null, true); + dasSpiel = g; + addMouseListener(this); + markiert = null; + } + + + + public void paint(Graphics g) { + + g.setColor(new Color(180, 180, 180)); + g.fillRect(0,0,getWidth(),getHeight()); + g.setColor(Color.BLACK); + g.fillRect(10, getHeight()-100, 840, 20); + for (int i = 0; i < 3; i++) + { + g.setColor(Color.BLACK); + g.fillRect(145+i*280, 60, 10, getHeight()-160); + int hoehe = dasSpiel.getTurmHoehe(i); + hoehe--; + int baseY = getHeight()-120-20*hoehe; + while(hoehe >= 0) + { + Scheibe s = dasSpiel.getNteScheibe(i, hoehe); + int y = baseY + 20*hoehe; + if (markiert == s) + { + y = 30; + } + s.zeichne(g, 150+280*i, y); + hoehe--; + } + } + } + + public void mouseExited(MouseEvent e) { + } + + public void mouseClicked(MouseEvent e) { + } + + public void mouseEntered(MouseEvent e){ + } + + public void mousePressed(MouseEvent e){ + } + + private int getArea(Point p) + { + return (int)p.getX()/(getWidth()/3); + } + + public void mouseReleased(MouseEvent e) + { + int stack = getArea(e.getPoint()); + if (markiert == null) + { + if (dasSpiel.getTurmHoehe(stack) > 0) + { + markiert = dasSpiel.getNteScheibe(stack, 0); + fromStack = stack; + repaint(); + } + } + else + { + if (fromStack == stack || dasSpiel.bewegeScheibe(fromStack, stack)) + { + markiert = null; + } + repaint(); + } + } + } +} diff --git a/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/HanoiGame.java b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/HanoiGame.java new file mode 100644 index 0000000..cc73961 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/HanoiGame.java @@ -0,0 +1,154 @@ +/** + * Das Spielfeld selbst + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class HanoiGame +{ + /** + * Das Array hat drei Elemente und stellt die drei Scheibenstapel dar. + */ + private Stack[] stapel; + + /** + * Verweis auf das Fenster-Objekt. + */ + HanoiFrame derFrame; + + /** + * Erzeugt ein neues Spiel mit 7 Scheiben + */ + public HanoiGame() + { + this(7); + } + + /** + * Erzeugt ein neues Spiel, die Anzahl der Scheiben kann zwischen 1 und 14 liegen. + * @param groesse Die Höhe des Stapels + */ + public HanoiGame(int groesse) + { + if (groesse > 14) + { + groesse = 14; + } + if (groesse < 1) + { + groesse = 1; + } + stapel = new Stack[3]; + for (int i = 0; i < 3; i++) + { + stapel[i] = new ArrayStack(); + } + while(groesse > 0) + { + stapel[0].push(new Scheibe(groesse)); + groesse--; + } + derFrame = new HanoiFrame(this); + } + + /** + * Gibt die Höhe des Turms zurück + * @param t Welcher Turm wird abgefragt? 0 = links, 1 = mitte, 2 = rechts + * @return Höhe des gefragten Turmes + */ + public int getTurmHoehe(int index) + { + Stack tmp = new ArrayStack(); + int size = 0; + while(!stapel[index].isEmpty()) + { + tmp.push(stapel[index].pop()); + size++; + } + while(!tmp.isEmpty()) + { + stapel[index].push(tmp.pop()); + } + return size; + } + + /** + * Gibt die n-te Scheibe auf Turm t zurück. n wird von oben gezählt, d.h. n = 0 ist die oberste Scheibe. + * @param t Die Nummer des Turmes (0 = links, 1 = mitte, 2 = rechts) + * @param n Die Nummer der Scheibe (0 <= n < getTurmHoehe(t)) + * @return Die gewünschte Scheibe + */ + public Scheibe getNteScheibe(int turm, int index) + { + Stack tmp = new ArrayStack(); + for (int i = 0; i < index; i++) + { + tmp.push(stapel[turm].pop()); + } + Scheibe s = stapel[turm].top(); + while(!tmp.isEmpty()) + { + stapel[turm].push(tmp.pop()); + } + return s; + } + + /** + * Verschiebt eine Scheibe von einem Turm auf den anderen, falls der Zug erlaubt ist + * @param von Die Nummer des Turms (0 = links, 1 = mitte, 2 = rechts), von dem weggezogen wird + * @param nach Die Nummer des Turms (0 = links, 1 = mitte, 2 = rechts), auf den hingezogen wird + * @return true, wenn der Zug erlaubt war; false sonst + */ + public boolean bewegeScheibe(int von, int nach) + { + if (stapel[von].isEmpty()) + { + return false; + } + Scheibe s = stapel[von].top(); + if (stapel[nach].isEmpty() || stapel[nach].top().getGroesse() > s.getGroesse()) + { + stapel[nach].push(stapel[von].pop()); + return true; + } + return false; + } + + /** + * Löst das Hanoi-Problem + */ + public void loese() + { + int n = getTurmHoehe(0); + if (getTurmHoehe(1) != 0 || getTurmHoehe(2) != 0) + { + System.out.println("Fehler: Nicht im Ausgangszustand"); + } + else + { + loese(n, 0, 2, 1); + } + } + + /** + * Löst das Hanoi-Problem rekursiv + * @param anzahl Die Anzahl der zu verschiebenden Scheiben + * @param von Die Nummer des Ausgangsstapels + * @param nach Die Nummer des Zielstapels + * @param ueber Die Nummer des Hilfsstapels + */ + private void loese(int anzahl, int von, int nach, int ueber) + { + if (anzahl > 1) + { + loese(anzahl-1, von, ueber, nach); + } + bewegeScheibe(von, nach); + derFrame.neuZeichnen(); + if (anzahl > 1) + { + loese(anzahl-1, ueber, nach, von); + } + } + +} diff --git a/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/README.TXT b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/README.TXT new file mode 100644 index 0000000..a6951c2 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Türme von Hanoi automatisch +PROJEKTZWECK: Implementieren Sie eine automatische Lösung für das Spiel "Die Türme von Hanoi" +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ "HanoiGame" +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/Scheibe.java b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/Scheibe.java new file mode 100644 index 0000000..fcf3fd3 --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/Scheibe.java @@ -0,0 +1,55 @@ +import javax.swing.*; +import java.awt.*; + +/** + * Repräsentiert eine Scheibe im Spiel "Die Türme von Hanoi" + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Scheibe +{ + final private Color farbe; + final private int groesse; + + /** + * Erzeugt eine neue Scheibe in der gewünschten Größe. + * Sollte nicht direkt aufgerufen werden! + * @param groesse Die Größe der Scheibe (1 bis 14) + */ + public Scheibe(int groesse) + { + Color[] farben = + { + Color.BLACK, + Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, + Color.CYAN, Color.MAGENTA, Color.ORANGE, Color.PINK, + Color.GRAY, new Color(0x6B8E23), new Color(0x4682B4), new Color(0x9ACD32), + new Color(0xBA55D3), new Color(0x228B22) + }; + this.groesse = groesse; + farbe = farben[groesse]; + } + + /** + * Zeichnet die Scheibe an der Position (x,y) auf das Graphics-Objekt g. + * Sollte nicht direkt aufgerufen werden. + * @param g Das Graphics-Objekt, auf das gezeichnet wird + * @param x Die x-Koordinate der oberen linken Ecke + * @param y Die y-Koordinate der oberen linken Ecke + */ + public void zeichne(Graphics g, int x, int y) + { + g.setColor(farbe); + g.fillRect(x-groesse*10, y, 20*groesse, 15); + } + + /** + * Gibt die Größe der Scheibe zurück + * @return Die Größe der Scheibe (0 bis 14) + */ + public int getGroesse() + { + return groesse; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/Stack.java b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/Stack.java new file mode 100644 index 0000000..332c28a --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/Stack.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Stack +{ + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); +} diff --git a/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/package.bluej b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/package.bluej new file mode 100644 index 0000000..ca2137b --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/03_hanoi_automatisch_loes/package.bluej @@ -0,0 +1,78 @@ +#BlueJ package file +dependency1.from=HanoiFrame +dependency1.to=HanoiGame +dependency1.type=UsesDependency +dependency2.from=HanoiFrame +dependency2.to=Scheibe +dependency2.type=UsesDependency +dependency3.from=HanoiGame +dependency3.to=HanoiFrame +dependency3.type=UsesDependency +dependency4.from=HanoiGame +dependency4.to=Stack +dependency4.type=UsesDependency +dependency5.from=HanoiGame +dependency5.to=ArrayStack +dependency5.type=UsesDependency +dependency6.from=HanoiGame +dependency6.to=Scheibe +dependency6.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1124 +editor.fx.0.x=552 +editor.fx.0.y=100 +objectbench.height=183 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.62 +package.editor.height=303 +package.editor.width=649 +package.editor.x=848 +package.editor.y=277 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=6 +package.numTargets=5 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=HanoiGame +target1.showInterface=false +target1.type=ClassTarget +target1.width=110 +target1.x=210 +target1.y=190 +target2.height=50 +target2.name=Scheibe +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=10 +target2.y=110 +target3.height=50 +target3.name=HanoiFrame +target3.showInterface=false +target3.type=ClassTarget +target3.width=110 +target3.x=110 +target3.y=20 +target4.height=50 +target4.name=ArrayStack +target4.showInterface=false +target4.type=ClassTarget +target4.width=120 +target4.x=380 +target4.y=140 +target5.height=50 +target5.name=Stack +target5.showInterface=false +target5.type=AbstractTarget +target5.width=80 +target5.x=400 +target5.y=20 diff --git a/Quellcodes/Alg_DS_Hanoi/readme.adoc b/Quellcodes/Alg_DS_Hanoi/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Hanoi/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Listenvarianten/.gitignore b/Quellcodes/Alg_DS_Listenvarianten/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/+libs/SizeOf.jar b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/+libs/SizeOf.jar new file mode 100644 index 0000000..d1cc0f5 Binary files /dev/null and b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/+libs/SizeOf.jar differ diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/+libs/license.txt b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/+libs/license.txt new file mode 100644 index 0000000..eeb85a6 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/+libs/license.txt @@ -0,0 +1,3 @@ +Quelle: https://github.com/afeinberg/sizeof +GNU Public License 2.0 +Modifikationen von Rainer Helfrich \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/Benchmark.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/Benchmark.java new file mode 100644 index 0000000..189660c --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/Benchmark.java @@ -0,0 +1,241 @@ +import liste.*; +import java.util.*; +import net.sourceforge.sizeof.*; +import java.io.*; +import java.lang.reflect.*; + +/** + * Testet Listenvarianten auf ihre Effizenz + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Benchmark +{ + private Liste dieListe; + private Random zufallszahlen; + + /** + * Erzeugt ein neues Benchmark-Objekt. Sollte nicht direkt aufgerufen werden. + * @param l Die Liste, die getestet werden soll. + */ + public Benchmark(Liste l) + { + dieListe = l; + zufallszahlen = new Random(); + } + + /** + * Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + * Sollte nicht direkt aufgerufen werden. + */ + public static void main(String[] args) + { + try + { + int anzahl = Integer.parseInt(args[0]); + Class c = Class.forName(args[1]); + Liste l = (Liste)c.newInstance(); + Benchmark b = new Benchmark(l); + Method m = b.getClass().getMethod(args[2], new Class[]{int.class}); + m.invoke(b, new Object[]{anzahl}); + System.out.println("@"+SizeOf.deepSizeOf((Object)l)+"@"); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + } + + /** + * Hängt Zufallszahlen an je eine Liste jedes Typs an und gibt den benötigten Speicher in Bytes aus + */ + public static void speichertestFuellen() + { + performMany("listeFuellen", true); + } + + /** + * Hängt Zufallszahlen an je eine Liste jedes Typs an, entfernt dann 3/4 der Werte wieder und gibt den benötigten Speicher in Bytes aus + */ + public static void speichertestFuellenUndEntfernen() + { + performMany("listeFuellenUnd34Entfernen", true); + } + + /** + * Fügt an je eine Liste jedes Typs vorne Zufallswerte ein und gibt die benötigte Laufzeit in µs aus. + */ + public static void laufzeittestVorneEinfuegen() + { + performMany("listeVorneAnfuegen", false); + } + + /** + * Fügt an je eine Liste jedes Typs hinten Zufallswerte ein und gibt die benötigte Laufzeit in µs aus. + */ + public static void laufzeittestHintenEinfuegen() + { + performMany("listeFuellen", false); + } + + /** + * Fügt an je eine Liste jedes Typs an zufälligen Stellen Zufallswerte ein und gibt die benötigte Laufzeit in µs aus. + */ + public static void laufzeittestZufaelligEinfuegen() + { + performMany("listeZufaelligEinfuegen", false); + } + + /** + * Füllt zuerst je eine Liste jedes Typs mit Zufallszahlen. + * Addiert dann alle Werte einer Liste auf und gibt die benötigte Laufzeit in µs aus. + * Es wird nur das Aufaddieren gemessen. + */ + public static void laufzeittestAufsummieren() + { + performMany("listeAufsummieren", false); + } + + private static void performMany(String strMethod, boolean isMemTest) + { + String[] typen = { "ListeMitArray", "ListeRekursiv", "ListeIterativ", "ListeMitEnde" }; + System.out.print("Anzahl"); + for (String s : typen) + { + System.out.print(";"+s); + } + System.out.println(); + int step = isMemTest ? 10 : 100; + for (int i = step; i <= 100*step; i += step) + { + System.out.print(i); + for (String s : typen) + { + int mem = performTest(s, strMethod, i, isMemTest); + System.out.print(";"+mem); + } + System.out.println(); + } + } + + private static int performTest(String typ, String methode, int anzahl, boolean isMemTest) + { + try + { + if (isMemTest) + { + Process process = new ProcessBuilder("java","-javaagent:./+libs/SizeOf.jar", Benchmark.class.getName(), ""+anzahl, "liste."+typ, methode).start(); + InputStream is = process.getInputStream(); + InputStreamReader isr = new InputStreamReader(is); + BufferedReader br = new BufferedReader(isr); + String line; + + StringBuilder sb = new StringBuilder(); + while ((line = br.readLine()) != null) { + sb.append(line); + } + String strOut = sb.toString(); + int idx = strOut.indexOf("@"); + if (idx < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int idx2 = strOut.indexOf("@", idx+1); + if (idx2 < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int n = Integer.parseInt(strOut.substring(idx+1, idx2)); + return n; + } + else + { + Class c = Class.forName("liste."+typ); + long summe = 0; + final int DURCHFUEHRUNGEN = 10; + for (int i = 0; i < DURCHFUEHRUNGEN; i++) + { + Liste l = (Liste)c.newInstance(); + Benchmark b = new Benchmark(l); + Method m = b.getClass().getMethod(methode, new Class[]{int.class}); + if (methode.equals("listeAufsummieren")) + { + b.listeFuellen(anzahl); + } + long vorher = System.nanoTime(); + m.invoke(b, new Object[]{anzahl}); + long nachher = System.nanoTime(); + summe += (nachher - vorher); + } + return (int)(summe/DURCHFUEHRUNGEN/1000); + } + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } + + /** + * Hängt Zufallszahlen an eine Liste an + */ + public void listeFuellen(int anzahl) + { + for (int i = 0; i < anzahl; i++) + { + dieListe.anhaengen(zufallszahlen.nextInt(1000000)); + } + } + + /** + * Hängt Zufallszahlen an eine Liste an und entfernt danach 3/4 der Zahlen wieder + */ + public void listeFuellenUnd34Entfernen(int anzahl) + { + listeFuellen(anzahl); + for (int i = 0; i < 0.75*anzahl; i++) + { + int index = zufallszahlen.nextInt(dieListe.laenge()); + dieListe.entferneBei(index); + } + } + + /** + * Fügt Zufallszahlen vorne an eine Liste an + */ + public void listeVorneAnfuegen(int anzahl) + { + for (int i = 0; i < anzahl; i++) + { + dieListe.einfuegenBei(0, zufallszahlen.nextInt(1000000)); + } + } + + /** + * Fügt Zufallszahlen an zufälligen Stellen in einer Liste ein + */ + public void listeZufaelligEinfuegen(int anzahl) + { + for (int i = 0; i < anzahl; i++) + { + int idx = zufallszahlen.nextInt(i+1); + dieListe.einfuegenBei(idx, zufallszahlen.nextInt(1000000)); + } + } + + /** + * Summiert alle Werte einer Liste auf + */ + public void listeAufsummieren(int anzahl) + { + int sum = 0; + int laenge = dieListe.laenge(); + for (int i = 0; i < laenge; i++) + { + sum += dieListe.getNtenWert(i); + } + } + +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/InsertionSort.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/InsertionSort.java new file mode 100644 index 0000000..c6eca14 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/InsertionSort.java @@ -0,0 +1,50 @@ +import liste.*; + +/** + * Sortiert eine Liste nach dem InsertionSort-Algorithmus + * + * @author Rainer Helfrich + * @version Januar 2021 + */ +public class InsertionSort extends SortierenMitBenchmark +{ + /** + * Erzeugt eine neue Testklasse für die übergebene Liste + * @param l Die Liste, die gefüllt und sortiert werden soll + */ + public InsertionSort(Liste l) + { + super(l); + } + + /** + * Gibt eine (ggf. neue) Liste zurück, die die Zahlen der Eingabeliste in sortierter Reihenfolge enthält + * @param l Die zu sortierende Liste; wird u.U. verändert. + * @return Eine Liste mit den sortierten Elementen der Eingabeliste + */ + protected Liste sortiere(Liste l) + { + Class c = l.getClass(); + try + { + Liste out = (Liste)c.getConstructor().newInstance(); + while(!l.istLeer()) + { + int value = l.getNtenWert(0); + l.entferneBei(0); + int index = 0; + int laenge = out.laenge(); + while(index < laenge && out.getNtenWert(index) < value) + { + index++; + } + out.einfuegenBei(index, value); + } + return out; + } + catch(Exception x) + { + return null; + } + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/MergeSort.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/MergeSort.java new file mode 100644 index 0000000..da3e6c9 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/MergeSort.java @@ -0,0 +1,74 @@ +import liste.*; + +/** + * Sortiert eine Liste nach dem MergeSort-Algorithmus + * + * @author Rainer Helfrich + * @version Januar 2021 + */ +public class MergeSort extends SortierenMitBenchmark +{ + /** + * Die Liste, die gefüllt und sortiert werden soll + */ + public MergeSort(Liste l) + { + super(l); + } + + /** + * Gibt eine (ggf. neue) Liste zurück, die die Zahlen der Eingabeliste in sortierter Reihenfolge enthält + * @param l Die zu sortierende Liste; wird u.U. verändert. + * @return Eine Liste mit den sortierten Elementen der Eingabeliste + */ + protected Liste sortiere(Liste l) + { + if (l.laenge() <= 1) + return l; + Class c = l.getClass(); + try + { + Liste links = (Liste)c.getConstructor().newInstance(); + int laenge = l.laenge(); + for (int i = 0; i < laenge/2; i++) + { + links.anhaengen(l.getNtenWert(0)); + l.entferneBei(0); + } + Liste rechts = l; + links = sortiere(links); + rechts = sortiere(rechts); + Liste out = (Liste)c.getConstructor().newInstance(); + while(!links.istLeer() && !rechts.istLeer()) + { + int lw = links.getNtenWert(0); + int rw = rechts.getNtenWert(0); + if (lw < rw) + { + out.anhaengen(lw); + links.entferneBei(0); + } + else + { + out.anhaengen(rw); + rechts.entferneBei(0); + } + } + while(!links.istLeer()) + { + out.anhaengen(links.getNtenWert(0)); + links.entferneBei(0); + } + while(!rechts.istLeer()) + { + out.anhaengen(rechts.getNtenWert(0)); + rechts.entferneBei(0); + } + return out; + } + catch(Exception x) + { + return null; + } + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/README.TXT b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/README.TXT new file mode 100644 index 0000000..d5a3129 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Listenvarianten - Benchmark +PROJEKTZWECK: Sie können hier verschiedene Implementationen des ADT Liste testen und auf ihre Speicher- und Laufzeiteffizienz prüfen. +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Rufen Sie die statischen Methoden (mit Ausnahme von main) der Klasse Benchmark auf, die Ausgabe erfolgt auf der Konsole +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SelectionSort.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SelectionSort.java new file mode 100644 index 0000000..346752b --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SelectionSort.java @@ -0,0 +1,55 @@ +import liste.*; + +/** + * Sortiert eine Liste nach dem SelectionSort-Algorithmus + * + * @author Rainer Helfrich + * @version Januar 2021 + */ +public class SelectionSort extends SortierenMitBenchmark +{ + /** + * Erzeugt eine neue Testklasse für die übergebene Liste + * @param l Die Liste, die gefüllt und sortiert werden soll + */ + public SelectionSort(Liste l) + { + super(l); + } + + /** + * Gibt eine (ggf. neue) Liste zurück, die die Zahlen der Eingabeliste in sortierter Reihenfolge enthält + * @param l Die zu sortierende Liste; wird u.U. verändert. + * @return Eine Liste mit den sortierten Elementen der Eingabeliste + */ + protected Liste sortiere(Liste l) + { + Class c = l.getClass(); + try + { + Liste out = (Liste)c.getConstructor().newInstance(); + while(!l.istLeer()) + { + int minIndex = 0; + int minValue = l.getNtenWert(0); + int laenge = l.laenge(); + for (int i = 1; i < laenge; i++) + { + int v = l.getNtenWert(i); + if (v < minValue) + { + minValue = v; + minIndex = i; + } + } + out.anhaengen(minValue); + l.entferneBei(minIndex); + } + return out; + } + catch(Exception x) + { + return null; + } + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SortierenMitBenchmark.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SortierenMitBenchmark.java new file mode 100644 index 0000000..7dd28a6 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SortierenMitBenchmark.java @@ -0,0 +1,68 @@ +import liste.*; +import java.util.Random; + +/** + * Sortiert eine Liste und gibt die benötigte Zeit aus. + * + * @author Rainer Helfrich + * @version Januar 2021 + */ +public abstract class SortierenMitBenchmark +{ + /** + * Die Liste, die sortiert werden soll + */ + private Liste dieListe; + + /** + * Erzeugt einen neuen Benchmark + * @param l Die Liste, die sortiert werden soll + */ + public SortierenMitBenchmark(Liste l) + { + dieListe = l; + } + + /** + * Gibt eine (ggf. neue) Liste zurück, die die Zahlen der Eingabeliste in sortierter Reihenfolge enthält + * @param l Die zu sortierende Liste; wird u.U. verändert. + * @return Eine Liste mit den sortierten Elementen der Eingabeliste + */ + protected abstract Liste sortiere(Liste l); + + /** + * Füllt die Liste mit neuen Werten, sortiert sie und misst die für das Sortieren nötige Zeit. + * Überprüft, ob die Sortierung korrekt war + * Gibt die Anzahl der Elemente sowie den Zeitbedarf auf der Konsole aus + * @param anzahl Die Anzahl der Elemente, die zufällig erzeugt werden sollen. + */ + public void sortiereUndMesse(int anzahl) + { + while(!dieListe.istLeer()) + { + dieListe.entferneBei(0); + } + Random r = new Random(); + for (int i = 0; i < anzahl; i++) + { + dieListe.anhaengen(r.nextInt(1000000)); + } + long vorher = System.currentTimeMillis(); + dieListe = sortiere(dieListe); + long nachher = System.currentTimeMillis(); + if (anzahl != dieListe.laenge()) + { + System.out.println("Fehler: Die sortiere Liste hat nicht die richtige Länge!"); + return; + } + for (int i = 1; i < anzahl; i++) + { + if (dieListe.getNtenWert(i-1) > dieListe.getNtenWert(i)) + { + System.out.println("Fehler bei Index " + i + ": Sortierung stimmt nicht."); + return; + } + } + System.out.println(getClass().getName() + ": " + anzahl + " Elemente, " + (nachher - vorher) + " ms"); + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SortiererTest.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SortiererTest.java new file mode 100644 index 0000000..bf1df26 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/SortiererTest.java @@ -0,0 +1,57 @@ +import liste.*; + +/** + * Führt verschiedene Sortierverfahren mit einer Liste aus + * + * @author Rainer Helfrich + * @version Januar 2020 + */ +public class SortiererTest +{ + /** + * Die Liste, die gefüllt und sortiert werden soll + */ + private Liste liste; + + /** + * Erzeugt eine neue Testklasse für die übergebene Liste + * @param liste Die Liste, die gefüllt und sortiert werden soll + */ + private SortiererTest(Liste liste) + { + this.liste = liste; + } + + /** + * Führt die drei Sortierverfahren SelectionSort, InsertionSort und MergeSort mit der Liste aus + * @param anzahl Die gewünschte Anzahl der Elemente + */ + private void sortierTestAusfuehren(int anzahl) + { + if (liste == null) + { + System.out.println("Fehler: Keine Liste gesetzt."); + return; + } + System.out.println("Listentyp: " + liste.getClass().getName()); + SortierenMitBenchmark smb = new SelectionSort(liste); + smb.sortiereUndMesse(anzahl); + smb = new InsertionSort(liste); + smb.sortiereUndMesse(anzahl); + smb = new MergeSort(liste); + smb.sortiereUndMesse(anzahl); + } + + /** + * Erzeugt eine neue Liste und führt den Sortiertest aus. + * @param anzahl Die gewünschte Anzahl der Elemente + */ + public static void testDurchfuehren(int anzahl) + { + //# TODO: Ersetzen Sie "null" durch einen Konstruktoraufruf einer Implementation des ADTs Liste. + Liste l = null; + + SortiererTest st = new SortiererTest(l); + st.sortierTestAusfuehren(anzahl); + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/Liste.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/Liste.java new file mode 100644 index 0000000..062861f --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/Liste.java @@ -0,0 +1,59 @@ +package liste; + +/** + * Der ADT Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Liste +{ + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public abstract int laenge(); + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public abstract T getNtenWert(int n); + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public abstract void anhaengen(T val); + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public abstract void einfuegenBei(int index, T val); + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public abstract void ausgeben(); + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public abstract boolean enthaelt(T val); + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public abstract void entferneBei(int index); + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public abstract boolean istLeer(); +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeIterativ.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeIterativ.java new file mode 100644 index 0000000..c24a0c5 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeIterativ.java @@ -0,0 +1,154 @@ +package liste; + +/** + * Eine einfach verkettete Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeIterativ extends ListeMitVerkettung +{ + /** + * Erzeugt eine neue Liste + */ + public ListeIterativ() + { + anfang = null; + } + + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public int laenge() + { + int len = 0; + Listenknoten k = anfang; + while (k != null) { + k = k.nachfolger; + len++; + } + return len; + } + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public T getNtenWert(int n) + { + Listenknoten k = anfang; + while (k != null) { + if (n == 0) { + return k.daten; + } + k = k.nachfolger; + n--; + } + return null; + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + Listenknoten neu = new Listenknoten(val, null); + if (anfang == null) + { + anfang = neu; + } + else + { + Listenknoten k = anfang; + while (k.nachfolger != null) { + k = k.nachfolger; + } + k.nachfolger = neu; + } + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + if (index == 0) + { + anfang = new Listenknoten(val, anfang); + } + else + { + Listenknoten k = anfang; + while (index > 1) { + if (k == null) { + return; + } + k = k.nachfolger; + index--; + } + if (k == null) { + return; + } + k.nachfolger = new Listenknoten(val, k.nachfolger); + } + } + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public void ausgeben() + { + Listenknoten k = anfang; + while (k != null) { + System.out.print(k.daten + " "); + k = k.nachfolger; + } + System.out.println(); + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public boolean enthaelt(T val) + { + Listenknoten k = anfang; + while (k != null) { + if (k.daten.equals(val)) { + return true; + } + k = k.nachfolger; + } + return false; + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + if (anfang == null) { + return; + } + if (index == 0) { + anfang = anfang.nachfolger; + } + else + { + Listenknoten tmp = anfang; + while (index > 1 && tmp != null) { + tmp = tmp.nachfolger; + index--; + } + if (tmp != null && tmp.nachfolger != null) { + tmp.nachfolger = tmp.nachfolger.nachfolger; + } + } + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitArray.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitArray.java new file mode 100644 index 0000000..736530f --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitArray.java @@ -0,0 +1,146 @@ +package liste; + +/** + * Eine ArrayList-artige Listenimplementation + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeMitArray extends Liste +{ + /** + * Das Array, das die Nutzdaten speichert + */ + private Object[] daten; + + /** + * Zähler, der angibt, wie viele der Werte im Array gültig sind + */ + private int anzahl; + + /** + * Erzeugt eine neue Liste + */ + public ListeMitArray() + { + daten = new Object[10]; + anzahl = 0; + } + + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public int laenge() + { + return anzahl; + } + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public void ausgeben() + { + for (int i = 0; i < anzahl; i++) + { + System.out.print(daten[i] + " "); + } + System.out.println(); + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + if (index >= 0 && index <= anzahl) + { + groessePruefen(); + for (int i = anzahl; i > index; i--) + { + daten[i] = daten[i-1]; + } + daten[index] = val; + anzahl++; + } + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + einfuegenBei(anzahl, val); + } + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public T getNtenWert(int n) + { + if (n >= 0 && n < anzahl) + { + return (T)daten[n]; + } + else + { + return null; + } + } + + private void groessePruefen() + { + if (anzahl >= daten.length) + { + Object[] tmp = new Object[daten.length*2]; + System.arraycopy(daten, 0, tmp, 0, anzahl); + daten = tmp; + } + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + if (index >= 0 && index < anzahl) + { + for (int i = index; i < anzahl-1; i++) + { + daten[i] = daten[i+1]; + } + anzahl--; + } + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public boolean enthaelt(T val) + { + for (int i = 0; i < anzahl; i++) + { + if (daten[i].equals(val)) + { + return true; + } + } + return false; + } + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public boolean istLeer() + { + return anzahl == 0; + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitEnde.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitEnde.java new file mode 100644 index 0000000..3a9baba --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitEnde.java @@ -0,0 +1,126 @@ +package liste; + +/** + * Eine einfach verkettete Liste mit Verweis auf den letzten Knoten + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeMitEnde extends ListeIterativ +{ + /** + * Der letzte Knoten der Liste + */ + private Listenknoten ende; + + /** + * Erzeugt eine neue Liste + */ + public ListeMitEnde() + { + super(); + ende = null; + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + Listenknoten neu = new Listenknoten(val, null); + if (anfang == null) + { + anfang = neu; + } + else + { + ende.nachfolger = neu; + } + ende = neu; + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + if (index == 0) + { + anfang = new Listenknoten(val, anfang); + if (ende == null) + { + ende = anfang; + } + } + else + { + Listenknoten k = anfang; + while (index > 1) { + if (k == null) { + return; + } + k = k.nachfolger; + index--; + } + if (k == null) { + return; + } + Listenknoten neu = new Listenknoten(val, k.nachfolger); + k.nachfolger = neu; + if (k == ende) + { + ende = neu; + } + } + } + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public boolean istLeer() + { + return anfang == null && ende == null; + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + if (anfang == null) + { + return; + } + if (index == 0) + { + anfang = anfang.nachfolger; + if (anfang == null) + { + ende = null; + } + } + else + { + Listenknoten tmp = anfang; + while (index > 1 && tmp != null) + { + tmp = tmp.nachfolger; + index--; + } + + if (tmp != null && tmp.nachfolger != null) + { + tmp.nachfolger = tmp.nachfolger.nachfolger; + if (tmp.nachfolger == null) + { + ende = tmp; + } + } + } + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitVerkettung.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitVerkettung.java new file mode 100644 index 0000000..9f92045 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeMitVerkettung.java @@ -0,0 +1,32 @@ +package liste; + +/** + * Eine einfach verkettete Liste + * + * @author Rainer Helfrich + * @version (Oktober 2020) + */ +public abstract class ListeMitVerkettung extends Liste +{ + /** + * Der erste Knoten der Liste + */ + protected Listenknoten anfang; + + /** + * Erzeugt eine neue Liste + */ + public ListeMitVerkettung() + { + anfang = null; + } + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public boolean istLeer() + { + return anfang == null; + } +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeRekursiv.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeRekursiv.java new file mode 100644 index 0000000..2f6c61a --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/ListeRekursiv.java @@ -0,0 +1,183 @@ +package liste; + +/** + * Eine einfach verkettete Liste, rekursiv implementiert + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeRekursiv extends ListeMitVerkettung +{ + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public int laenge() + { + return laenge(anfang); + } + + private int laenge(Listenknoten k) + { + if (k == null) { + return 0; + } + return 1 + laenge(k.nachfolger); + } + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public T getNtenWert(int n) + { + return getNtenWert(anfang, n); + } + + private T getNtenWert(Listenknoten k, int n) + { + if (n == 0) { + if (k == null) { + return null; + } + else { + return k.daten; + } + } + return getNtenWert(k.nachfolger, n-1); + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + if (anfang == null) + { + anfang = new Listenknoten(val, null); + } + else + { + anhaengen(anfang, val); + } + } + + private void anhaengen(Listenknoten k, T val) + { + if (k == null) + { + return; + } + if (k.nachfolger == null) + { + k.nachfolger = new Listenknoten(val, null); + } + else + { + anhaengen(k.nachfolger, val); + } + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + if (index == 0) + { + anfang = new Listenknoten(val, anfang); + } + else + { + einfuegenBei(anfang, index, val); + } + } + + private void einfuegenBei(Listenknoten k, int index, T val) + { + if (index == 1) + { + k.nachfolger = new Listenknoten(val, k.nachfolger); + } + else + { + einfuegenBei(k.nachfolger, index-1, val); + } + } + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public void ausgeben() + { + ausgeben(anfang); + } + + private void ausgeben(Listenknoten k) + { + if (k == null) { + System.out.println(); + } + else + { + System.out.print(k.daten + " "); + ausgeben(k.nachfolger); + } + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public boolean enthaelt(T val) + { + return enthaelt(anfang, val); + } + + private boolean enthaelt(Listenknoten k, T val) + { + if (k == null) { + return false; + } + if (k.daten.equals(val)) { + return true; + } + return enthaelt(k.nachfolger, val); + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + if (anfang == null) { + return; + } + if (index == 0) { + anfang = anfang.nachfolger; + } + else + { + entferneBei(anfang, index); + } + } + + private void entferneBei(Listenknoten k, int index) + { + if (k != null && k.nachfolger != null) { + if (index == 1) + { + k.nachfolger = k.nachfolger.nachfolger; + } + else + { + entferneBei(k.nachfolger, index-1); + } + } + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/Listenknoten.java b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/Listenknoten.java new file mode 100644 index 0000000..6dcba5a --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/Listenknoten.java @@ -0,0 +1,33 @@ +package liste; + +/** + * Ein Knoten einer verketteten Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Listenknoten +{ + /** + * Der Datenwert des Listenknotens + */ + public T daten; + + /** + * Der Nachfolger des Listenknotens + */ + public Listenknoten nachfolger; + + /** + * Erzeugt einen neuen Listenknoten + * + * @param daten Der Datenwert des Knotens + * @param nachfolger Der Nachfolger des Knotens + */ + public Listenknoten(T daten, Listenknoten nachfolger) + { + this.daten = daten; + this.nachfolger = nachfolger; + } + +} diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/package.bluej b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/package.bluej new file mode 100644 index 0000000..7264372 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/liste/package.bluej @@ -0,0 +1,81 @@ +#BlueJ package file +dependency1.from=ListeMitVerkettung +dependency1.to=Listenknoten +dependency1.type=UsesDependency +dependency2.from=ListeRekursiv +dependency2.to=Listenknoten +dependency2.type=UsesDependency +dependency3.from=ListeMitEnde +dependency3.to=Listenknoten +dependency3.type=UsesDependency +dependency4.from=ListeIterativ +dependency4.to=Listenknoten +dependency4.type=UsesDependency +objectbench.height=90 +objectbench.width=1269 +package.divider.horizontal=0.6 +package.divider.vertical=0.8310104529616724 +package.editor.height=470 +package.editor.width=1158 +package.editor.x=20 +package.editor.y=20 +package.frame.height=674 +package.frame.width=1309 +package.numDependencies=4 +package.numTargets=7 +package.showExtends=true +package.showUses=true +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=ListeMitArray +target1.showInterface=false +target1.type=ClassTarget +target1.width=140 +target1.x=530 +target1.y=260 +target2.height=50 +target2.name=ListeIterativ +target2.showInterface=false +target2.type=ClassTarget +target2.width=120 +target2.x=330 +target2.y=260 +target3.height=50 +target3.name=ListeMitVerkettung +target3.showInterface=false +target3.type=AbstractTarget +target3.width=170 +target3.x=250 +target3.y=170 +target4.height=50 +target4.name=Liste +target4.showInterface=false +target4.type=AbstractTarget +target4.width=80 +target4.x=460 +target4.y=80 +target5.height=50 +target5.name=ListeMitEnde +target5.showInterface=false +target5.type=ClassTarget +target5.width=150 +target5.x=410 +target5.y=360 +target6.height=50 +target6.name=ListeRekursiv +target6.showInterface=false +target6.type=ClassTarget +target6.width=130 +target6.x=150 +target6.y=260 +target7.height=50 +target7.name=Listenknoten +target7.showInterface=false +target7.type=ClassTarget +target7.width=170 +target7.x=240 +target7.y=40 diff --git a/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/package.bluej b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/package.bluej new file mode 100644 index 0000000..6540bc6 --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/01_listenvarianten_benchmark_roh/package.bluej @@ -0,0 +1,85 @@ +#BlueJ package file +dependency1.from=SortiererTest +dependency1.to=SortierenMitBenchmark +dependency1.type=UsesDependency +dependency2.from=SortiererTest +dependency2.to=SelectionSort +dependency2.type=UsesDependency +dependency3.from=SortiererTest +dependency3.to=InsertionSort +dependency3.type=UsesDependency +dependency4.from=SortiererTest +dependency4.to=MergeSort +dependency4.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=816 +editor.fx.0.x=732 +editor.fx.0.y=137 +objectbench.height=138 +objectbench.width=1587 +package.divider.horizontal=0.6 +package.divider.vertical=0.8092105263157895 +package.editor.height=608 +package.editor.width=1476 +package.editor.x=264 +package.editor.y=206 +package.frame.height=860 +package.frame.width=1627 +package.numDependencies=4 +package.numTargets=7 +package.showExtends=false +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=SortiererTest +target1.showInterface=false +target1.type=ClassTarget +target1.width=110 +target1.x=310 +target1.y=90 +target2.height=62 +target2.name=liste +target2.type=PackageTarget +target2.width=80 +target2.x=80 +target2.y=100 +target3.height=50 +target3.name=SortierenMitBenchmark +target3.showInterface=false +target3.type=AbstractTarget +target3.width=170 +target3.x=400 +target3.y=190 +target4.height=50 +target4.name=Benchmark +target4.showInterface=false +target4.type=ClassTarget +target4.width=90 +target4.x=70 +target4.y=180 +target5.height=50 +target5.name=SelectionSort +target5.showInterface=false +target5.type=ClassTarget +target5.width=110 +target5.x=220 +target5.y=170 +target6.height=50 +target6.name=InsertionSort +target6.showInterface=false +target6.type=ClassTarget +target6.width=110 +target6.x=220 +target6.y=230 +target7.height=50 +target7.name=MergeSort +target7.showInterface=false +target7.type=ClassTarget +target7.width=90 +target7.x=240 +target7.y=290 diff --git a/Quellcodes/Alg_DS_Listenvarianten/readme.adoc b/Quellcodes/Alg_DS_Listenvarianten/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Listenvarianten/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Queue/.gitignore b/Quellcodes/Alg_DS_Queue/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/ArrayQueue.java b/Quellcodes/Alg_DS_Queue/01_queue_roh/ArrayQueue.java new file mode 100644 index 0000000..b204971 --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/01_queue_roh/ArrayQueue.java @@ -0,0 +1,53 @@ + +/** + * Queue basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayQueue extends Queue +{ + /** + * Erzeugt eine neue, leere Queue + */ + public ArrayQueue() + { + + } + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public void enqueue(T x) + { + + } + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public T front() + { + return null; + } + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public T dequeue() + { + return null; + } + + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public boolean isEmpty() + { + return false; + } +} diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/ArrayQueueTester.java b/Quellcodes/Alg_DS_Queue/01_queue_roh/ArrayQueueTester.java new file mode 100644 index 0000000..0067c37 --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/01_queue_roh/ArrayQueueTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für die ArrayQueue + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayQueueTester extends QueueTester +{ + @Before + public void setUp() + { + theQueue = new ArrayQueue(); + } +} diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/LinkedQueue.java b/Quellcodes/Alg_DS_Queue/01_queue_roh/LinkedQueue.java new file mode 100644 index 0000000..d83c20a --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/01_queue_roh/LinkedQueue.java @@ -0,0 +1,52 @@ + +/** + * Eine Queue basierend auf einer verketteten Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedQueue extends Queue +{ + /** + * Erzeugt eine neue, leere Queue + */ + public LinkedQueue() + { + + } + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public T front() + { + return null; + } + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public T dequeue() + { + return null; + } + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public void enqueue(T x) + { + } + + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public boolean isEmpty() + { + return false; + } +} diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/LinkedQueueTester.java b/Quellcodes/Alg_DS_Queue/01_queue_roh/LinkedQueueTester.java new file mode 100644 index 0000000..186e60b --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/01_queue_roh/LinkedQueueTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für die LinkedQueue + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedQueueTester extends QueueTester +{ + @Before + public void setUp() + { + theQueue = new LinkedQueue(); + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/Queue.java b/Quellcodes/Alg_DS_Queue/01_queue_roh/Queue.java new file mode 100644 index 0000000..7e60a9f --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/01_queue_roh/Queue.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Queues + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Queue +{ + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public abstract void enqueue(T x); + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public abstract T dequeue(); + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public abstract T front(); +} diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/QueueTester.java b/Quellcodes/Alg_DS_Queue/01_queue_roh/QueueTester.java new file mode 100644 index 0000000..7ce415c --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/01_queue_roh/QueueTester.java @@ -0,0 +1,5004 @@ +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Die Test-Klasse QueueTester. + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class QueueTester +{ + protected Queue theQueue; + + @Test + public void test01() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(25); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(77); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(621); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(672); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(601); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(975); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(254); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(385); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(493); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(322); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(581); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(432); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(25,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(77,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(77,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(621,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(672,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(601,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(975,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(254,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(385,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(493,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(322,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(581,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(432,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(979); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(301); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(352); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(533); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(146); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(979,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(301,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(352,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(533,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(146,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(406); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(406,theQueue.front().intValue()); + theQueue.enqueue(786); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(406,theQueue.front().intValue()); + theQueue.enqueue(897); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(406,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(406,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(241); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(999); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(808); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(786,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(897,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(241,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(999,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(808,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(47); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(47,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(47,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(312); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(312,theQueue.front().intValue()); + theQueue.enqueue(498); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(312,theQueue.front().intValue()); + theQueue.enqueue(551); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(312,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(312,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(498,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(551,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(69); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + theQueue.enqueue(863); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(69,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + theQueue.enqueue(615); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(863,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(924,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(281); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(293); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(928); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(86); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(615,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(281,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(293,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(928,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(86,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(100); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(899); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(100,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(899,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(340); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(340,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(340,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(13); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(13,theQueue.front().intValue()); + theQueue.enqueue(596); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(13,theQueue.front().intValue()); + theQueue.enqueue(950); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(13,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(13,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(596,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(950,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(169); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(169,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(169,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(52); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(574); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(52,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(574,theQueue.front().intValue()); + theQueue.enqueue(792); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(574,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(574,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(678); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(348); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(597); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(597); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(632); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(578); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(480); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(682); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(792,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(276); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(731); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(941); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(55); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(897); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(864); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(640); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(571); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(678,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(348,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(597,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(597,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(632,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(578,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(480,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(682,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(276,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(731,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(941,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(55,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(897,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(864,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(640,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(571,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(940); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(926); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(388); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(940,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(926,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(388,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(869); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(869,theQueue.front().intValue()); + theQueue.enqueue(109); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(869,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(869,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(109,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(33); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(33,theQueue.front().intValue()); + theQueue.enqueue(711); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(33,theQueue.front().intValue()); + theQueue.enqueue(253); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(33,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(33,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + theQueue.enqueue(280); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + theQueue.enqueue(899); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + theQueue.enqueue(453); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + } + + @Test + public void test02() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(295); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(295,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(295,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(6); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(954); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(907); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(857); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(164); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(668); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(6,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(869); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(353); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(83); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(730); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(954,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + theQueue.enqueue(766); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + theQueue.enqueue(405); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + theQueue.enqueue(791); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(907,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(857,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(857,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(503); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(899); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(880); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(845); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(137); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(164,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(668,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(668,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(869,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(869,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(889); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(461); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(143); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(242); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(986); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(491); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(353,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(83,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(730,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(766,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(405,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(791,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(503,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(899,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(880,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(845,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(137,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(889,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(461,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(143,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(242,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(986,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(491,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(35); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(35,theQueue.front().intValue()); + theQueue.enqueue(473); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(35,theQueue.front().intValue()); + theQueue.enqueue(870); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(35,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(35,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(473,theQueue.front().intValue()); + theQueue.enqueue(332); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(473,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(473,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(870,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(870,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(332,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(851); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(851,theQueue.front().intValue()); + theQueue.enqueue(752); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(851,theQueue.front().intValue()); + theQueue.enqueue(756); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(851,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(851,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(752,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(756,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(970); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(970,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(970,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(227); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(227,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(227,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(453); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(453,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(453,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(584); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(584,theQueue.front().intValue()); + theQueue.enqueue(882); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(584,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(584,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(882,theQueue.front().intValue()); + theQueue.enqueue(134); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(882,theQueue.front().intValue()); + theQueue.enqueue(514); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(882,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(882,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(134,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(134,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(514,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(79); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(990); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(574); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(146); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(967); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(597); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(79,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(990,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(990,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(574,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(146,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(967,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(597,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(725); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(725,theQueue.front().intValue()); + theQueue.enqueue(482); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(725,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(725,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + theQueue.enqueue(662); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(482,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(662,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(662,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(482); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + theQueue.enqueue(643); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(482,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(643,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(862); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(862,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(862,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(573); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(573,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(573,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(845); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(845,theQueue.front().intValue()); + theQueue.enqueue(109); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(845,theQueue.front().intValue()); + theQueue.enqueue(326); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(845,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(845,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + theQueue.enqueue(404); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + theQueue.enqueue(398); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + theQueue.enqueue(251); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(109,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(326,theQueue.front().intValue()); + theQueue.enqueue(836); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(326,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(326,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(404,theQueue.front().intValue()); + theQueue.enqueue(71); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(404,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(404,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(398,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(398,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(251,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(836,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(71,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(166); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(166,theQueue.front().intValue()); + theQueue.enqueue(642); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(166,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(166,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(642,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(642,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(690); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(690,theQueue.front().intValue()); + } + + @Test + public void test03() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(474); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(708); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(120); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(368); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(844); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(816); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(474,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(708,theQueue.front().intValue()); + theQueue.enqueue(100); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(708,theQueue.front().intValue()); + theQueue.enqueue(497); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(708,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(708,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(120,theQueue.front().intValue()); + theQueue.enqueue(491); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(120,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(120,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(368,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(368,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(844,theQueue.front().intValue()); + theQueue.enqueue(504); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(844,theQueue.front().intValue()); + theQueue.enqueue(647); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(844,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(844,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(816,theQueue.front().intValue()); + theQueue.enqueue(219); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(816,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(816,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(100,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(497,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(491,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(504,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(647,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(219,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(474); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(328); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(429); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(890); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(474,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(328,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(429,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(890,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(863); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(863,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(426); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(426,theQueue.front().intValue()); + theQueue.enqueue(699); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(426,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(426,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(699,theQueue.front().intValue()); + theQueue.enqueue(988); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(699,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(699,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(988,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(564,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(912); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(912,theQueue.front().intValue()); + theQueue.enqueue(0); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(912,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(912,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(912,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(0,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(197); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(197,theQueue.front().intValue()); + theQueue.enqueue(940); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(197,theQueue.front().intValue()); + theQueue.enqueue(229); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(197,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(197,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(231); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(722); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(940,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(68); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(977); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(294); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(670); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(494); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(243); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(169); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(159); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(189); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(623); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(229,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(231,theQueue.front().intValue()); + theQueue.enqueue(544); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(231,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(231,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(722,theQueue.front().intValue()); + theQueue.enqueue(922); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(722,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(722,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(68,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(68,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(977,theQueue.front().intValue()); + theQueue.enqueue(237); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(977,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(977,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(515); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(886); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(930); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(874); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(294,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + theQueue.enqueue(144); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + theQueue.enqueue(185); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + theQueue.enqueue(796); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(670,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(494,theQueue.front().intValue()); + theQueue.enqueue(833); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(494,theQueue.front().intValue()); + theQueue.enqueue(395); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(494,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(494,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(243,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(169,theQueue.front().intValue()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(169,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(169,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(159,theQueue.front().intValue()); + theQueue.enqueue(679); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(159,theQueue.front().intValue()); + theQueue.enqueue(940); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(159,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(159,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(189,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(831); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(654); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(5); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(275); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(675); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(623,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(544,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(922,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(237,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(515,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(886,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(930,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(874,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(144,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(185,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(796,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(833,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(395,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(679,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(940,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(831,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(654,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(5,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(275,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(675,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(383); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(383,theQueue.front().intValue()); + theQueue.enqueue(974); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(383,theQueue.front().intValue()); + theQueue.enqueue(99); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(383,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(383,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(974,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(99,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(635); + assertFalse(theQueue.isEmpty()); + + assertNotNull(theQueue.front()); + assertEquals(635,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(635,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(504); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + theQueue.enqueue(896); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + theQueue.enqueue(77); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + theQueue.enqueue(312); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(504,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(896,theQueue.front().intValue()); + } + + @Test + public void test04() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(723); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(723,theQueue.front().intValue()); + theQueue.enqueue(537); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(723,theQueue.front().intValue()); + theQueue.enqueue(78); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(723,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(723,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(537,theQueue.front().intValue()); + theQueue.enqueue(386); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(537,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(537,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(537,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(78,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(386,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(569); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(569,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(569,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(906,theQueue.front().intValue()); + theQueue.enqueue(192); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(906,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(192,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(665); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(665,theQueue.front().intValue()); + theQueue.enqueue(398); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(665,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(665,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(398,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(398,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(23); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(970); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(656); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(235); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(797); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(210); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(59); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(23,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(970,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(656,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(235,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(797,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(210,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(59,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(506); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(938); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(135); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(126); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(573); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(506,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(938,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(938,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + theQueue.enqueue(920); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + theQueue.enqueue(412); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + theQueue.enqueue(5); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(135,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(126,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(126,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(573,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(920,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(412,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(5,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(145); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(616); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(885); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(74); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(843); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(926); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(145,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(616,theQueue.front().intValue()); + theQueue.enqueue(520); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(616,theQueue.front().intValue()); + theQueue.enqueue(24); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(616,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(616,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(885,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(74,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(843,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(926,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(520,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(24,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(898); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + theQueue.enqueue(547); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + theQueue.enqueue(621); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + theQueue.enqueue(170); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(898,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(547,theQueue.front().intValue()); + theQueue.enqueue(537); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(547,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(547,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(621,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(621,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(170,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(537,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(936); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(239); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(114); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(165); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(420); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(362); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(936,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(239,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(114,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(165,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(420,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(362,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(344); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(284); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(292); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(572); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(306); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(557); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(321); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(344,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(284,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(292,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(572,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(306,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(557,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(321,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(605); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(605,theQueue.front().intValue()); + theQueue.enqueue(387); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(605,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(605,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(387,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(387,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(509); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(509,theQueue.front().intValue()); + theQueue.enqueue(498); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(509,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(509,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(374); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(421); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(604); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(555); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(1); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(881); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(372); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(498,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(374,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(374,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + theQueue.enqueue(685); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + theQueue.enqueue(187); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + theQueue.enqueue(498); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(421,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(604,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(604,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(659); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(62); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(868); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(34); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(799); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + } + + @Test + public void test05() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(302); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(302,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(302,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(376); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + theQueue.enqueue(858); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + theQueue.enqueue(488); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + theQueue.enqueue(673); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(376,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(374); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(557); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(766); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(914); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(447); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(858,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + theQueue.enqueue(390); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + theQueue.enqueue(892); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(488,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(434); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(96); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(642); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(144); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(664); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(751); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(492); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(339); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(801); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(244); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(806); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(612); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(511); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(673,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(374,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(557,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(766,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(914,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(447,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(390,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(892,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(434,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(96,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(642,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(144,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(664,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(751,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(492,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(339,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(801,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(244,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(806,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(612,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(511,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(821); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(821,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(564,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(60); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(60,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(60,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(514); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(514,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(514,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(727); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(727,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(727,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(377); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(846); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(990); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(904); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(271); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(377,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(846,theQueue.front().intValue()); + theQueue.enqueue(732); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(846,theQueue.front().intValue()); + theQueue.enqueue(37); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(846,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(846,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(990,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(904,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(271,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(732,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(37,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(967); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(62); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(661); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(139); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(106); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(967,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(62,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(62,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(661,theQueue.front().intValue()); + theQueue.enqueue(64); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(661,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(661,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(139,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(106,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(64,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(848); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(848,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(848,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(864); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(864,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(864,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(864); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(864,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(864,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(804); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(804,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(804,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(37); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(37,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + theQueue.enqueue(510); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(510,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(706); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(978); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(769); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(863); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(516); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(783); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(706,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(276); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(74); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(311); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(350); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(978,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(769,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(863,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(516,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(783,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(276,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(74,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(311,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(350,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(773); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(773,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(773,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(424); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(424,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(416); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(416,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(416,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(420); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(837); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(319); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(879); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(142); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(420,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(837,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(837,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(319,theQueue.front().intValue()); + theQueue.enqueue(464); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(319,theQueue.front().intValue()); + } + + @Test + public void test06() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(212); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(212,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(212,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(555); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(555,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(721); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(721,theQueue.front().intValue()); + theQueue.enqueue(205); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(721,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(721,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + theQueue.enqueue(896); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + theQueue.enqueue(667); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + theQueue.enqueue(343); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(205,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(896,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(896,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(667,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(343,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(932); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(834); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(580); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(120); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(622); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(219); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(133); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(902); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(857); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(898); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(505); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(932,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(834,theQueue.front().intValue()); + theQueue.enqueue(156); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(834,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(834,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(580,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(120,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(622,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(219,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(133,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(902,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(857,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(898,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(505,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(156,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(431); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(431,theQueue.front().intValue()); + theQueue.enqueue(578); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(431,theQueue.front().intValue()); + theQueue.enqueue(611); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(431,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(431,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(578,theQueue.front().intValue()); + theQueue.enqueue(542); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(578,theQueue.front().intValue()); + theQueue.enqueue(838); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(578,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(578,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(237); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(387); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(946); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(311); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(404); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(800); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(433); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(611,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(542,theQueue.front().intValue()); + theQueue.enqueue(215); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(542,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(542,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(838,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(838,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(237,theQueue.front().intValue()); + theQueue.enqueue(542); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(237,theQueue.front().intValue()); + theQueue.enqueue(424); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(237,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(237,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(387,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(946,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(311,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(404,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(800,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(433,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(215,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(542,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(424,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(991); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(991,theQueue.front().intValue()); + theQueue.enqueue(204); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(991,theQueue.front().intValue()); + theQueue.enqueue(695); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(991,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(991,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(204,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(695,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(6); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(51); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(261); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(6,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(51,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(261,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(753); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(753,theQueue.front().intValue()); + theQueue.enqueue(292); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(753,theQueue.front().intValue()); + theQueue.enqueue(34); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(753,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(753,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(292,theQueue.front().intValue()); + theQueue.enqueue(744); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(292,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(292,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(34,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(34,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(744,theQueue.front().intValue()); + theQueue.enqueue(790); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(744,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(744,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(790,theQueue.front().intValue()); + theQueue.enqueue(579); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(790,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(790,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(579,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(579,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(579,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(335); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(335,theQueue.front().intValue()); + theQueue.enqueue(460); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(335,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(335,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(460,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(614); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(874); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(375); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(908); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(651); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(614,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(356); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(661); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(113); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(200); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(874,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(375,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(908,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(651,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(356,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(661,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(113,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(200,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(598); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(29); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(960); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(147); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(713); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(820); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(598,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(29,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(960,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(147,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(713,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(820,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(562); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(562,theQueue.front().intValue()); + theQueue.enqueue(411); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(562,theQueue.front().intValue()); + theQueue.enqueue(399); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(562,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(562,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(411,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(399,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(334); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(334,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(334,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(778); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(778,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(778,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(386); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(386,theQueue.front().intValue()); + theQueue.enqueue(613); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(386,theQueue.front().intValue()); + } + + @Test + public void test07() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(642); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(642,theQueue.front().intValue()); + theQueue.enqueue(189); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(642,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(642,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + theQueue.enqueue(68); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + theQueue.enqueue(533); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(189,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(68,theQueue.front().intValue()); + theQueue.enqueue(4); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(68,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(68,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(533); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(747); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(533,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(345); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(370); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(531); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(217); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(569); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(902); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(712); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(569); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(852); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(4,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(27); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(833); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(839); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(533,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(747,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(345,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(370,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(531,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(217,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(569,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(902,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(712,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(569,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(852,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(27,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(833,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(839,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(152); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + theQueue.enqueue(646); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + theQueue.enqueue(405); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + theQueue.enqueue(226); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(152,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(646,theQueue.front().intValue()); + theQueue.enqueue(66); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(646,theQueue.front().intValue()); + theQueue.enqueue(206); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(646,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(646,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + theQueue.enqueue(495); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + theQueue.enqueue(152); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + theQueue.enqueue(454); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(405,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(331); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(736); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(627); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(226,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(66,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(206,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(495,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(152,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(454,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(331,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(736,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(627,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(350); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(350,theQueue.front().intValue()); + theQueue.enqueue(37); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(350,theQueue.front().intValue()); + theQueue.enqueue(277); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(350,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(350,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + theQueue.enqueue(667); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(37,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(277,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(667,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(712); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(712,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(712,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(566); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(566,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(566,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(853); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(853,theQueue.front().intValue()); + theQueue.enqueue(12); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(853,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(853,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(12,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(179); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(179,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(179,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(767); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(927); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(397); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(961); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(423); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(781); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(767,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(927,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(397,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(961,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(423,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(781,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(555); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(555,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(634); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(634,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(634,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(525); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(525,theQueue.front().intValue()); + theQueue.enqueue(185); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(525,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(525,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(185,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(832); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(832,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(832,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(52); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(307); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(306); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(837); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(902); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(52,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(307,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(306,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(837,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(902,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(945); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(945,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(945,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(178); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(107); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(606); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(452); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(973); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(178,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(107,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(606,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(452,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(973,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(635); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(635,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(635,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(391); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(391,theQueue.front().intValue()); + theQueue.enqueue(311); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(391,theQueue.front().intValue()); + theQueue.enqueue(989); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(391,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(391,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(311,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(311,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(989,theQueue.front().intValue()); + theQueue.enqueue(856); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(989,theQueue.front().intValue()); + } + + @Test + public void test08() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(493); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(288); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(72); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(576); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(26); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(502); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(493,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(288,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(72,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(576,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(26,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(502,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(69); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + theQueue.enqueue(908); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + theQueue.enqueue(717); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(69,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(908,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(717,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(513); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(101); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(158); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(876); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(459); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(72); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(928); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(91); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(911); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(513,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + theQueue.enqueue(558); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + theQueue.enqueue(103); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + theQueue.enqueue(67); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(101,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(158,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(876,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(459,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(72,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(928,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(91,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(911,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(558,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(103,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(67,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(515); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(515,theQueue.front().intValue()); + theQueue.enqueue(797); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(515,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(515,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(797,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(821); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(425); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(266); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(598); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(332); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(821,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(41); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(848); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(531); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(478); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(794); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(834); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(425,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(266,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(598,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(332,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(41,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(848,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(531,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(478,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(794,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(834,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(138); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(138,theQueue.front().intValue()); + theQueue.enqueue(794); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(138,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(138,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(794,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(794,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(986); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(986,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(986,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(904); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + theQueue.enqueue(297); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + theQueue.enqueue(824); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + theQueue.enqueue(999); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(904,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(297,theQueue.front().intValue()); + theQueue.enqueue(645); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(297,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(297,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(824,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(999,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(645,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(839); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(521); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(581); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(915); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(199); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(839,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(521,theQueue.front().intValue()); + theQueue.enqueue(474); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(521,theQueue.front().intValue()); + theQueue.enqueue(655); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(521,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(521,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(581,theQueue.front().intValue()); + theQueue.enqueue(373); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(581,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(581,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + theQueue.enqueue(231); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + theQueue.enqueue(409); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + theQueue.enqueue(582); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(915,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(49); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(880); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(767); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(242); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(771); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(199,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(474,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(655,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(373,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(231,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(409,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(582,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(49,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(880,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(767,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(242,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(771,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(48); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(48,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(48,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(0); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(25); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(869); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(191); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(4); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(0,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(25,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(869,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(191,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(4,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + theQueue.enqueue(947); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + theQueue.enqueue(935); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(947,theQueue.front().intValue()); + theQueue.enqueue(816); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(947,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(947,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(935,theQueue.front().intValue()); + theQueue.enqueue(853); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(935,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(935,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(816,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(853,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(411); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(411,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(411,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(206); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + theQueue.enqueue(511); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + theQueue.enqueue(122); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + theQueue.enqueue(499); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + } + + @Test + public void test09() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(436); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(436,theQueue.front().intValue()); + theQueue.enqueue(622); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(436,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(436,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(622,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(664); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + theQueue.enqueue(114); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + theQueue.enqueue(168); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + theQueue.enqueue(259); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(664,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(114,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(168,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(259,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(747); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(724); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(255); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(638); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(8); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(455); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(747,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(397); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(916); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(206); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(49); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(347); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(724,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(255,theQueue.front().intValue()); + theQueue.enqueue(817); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(255,theQueue.front().intValue()); + theQueue.enqueue(561); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(255,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(255,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(994); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(957); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(380); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(729); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(231); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(473); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(638,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(8,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(455,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(397,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(916,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(206,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(49,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(347,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(817,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(561,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(994,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(957,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(380,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(729,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(231,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(473,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(886); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(886,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(886,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(27); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(27,theQueue.front().intValue()); + theQueue.enqueue(913); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(27,theQueue.front().intValue()); + theQueue.enqueue(544); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(27,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(27,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(913,theQueue.front().intValue()); + theQueue.enqueue(666); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(913,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(913,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(544,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(666,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(343); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(343,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(343,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(123); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(123,theQueue.front().intValue()); + theQueue.enqueue(867); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(123,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(123,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(867,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(808); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(497); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(580); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(949); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(356); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(465); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(808,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(497,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(580,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(949,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(356,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(465,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(519); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(519,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(519,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(115); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(115,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(115,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(424); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(42); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(397); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(644); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(189); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(75); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(45); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(424,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(42,theQueue.front().intValue()); + theQueue.enqueue(439); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(42,theQueue.front().intValue()); + theQueue.enqueue(896); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(42,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(42,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(873); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(517); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(428); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(39); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(183); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(181); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(397,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(786); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(321); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(619); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(349); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(504); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(644,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + theQueue.enqueue(742); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(189,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(75,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(75,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(45,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(45,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(439,theQueue.front().intValue()); + theQueue.enqueue(783); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(439,theQueue.front().intValue()); + theQueue.enqueue(786); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(439,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(439,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(896,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(896,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(873,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(517,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(428,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(39,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(183,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(181,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(786,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(321,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(619,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(349,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(504,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(742,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(783,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(786,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(613); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(613,theQueue.front().intValue()); + theQueue.enqueue(102); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(613,theQueue.front().intValue()); + theQueue.enqueue(598); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(613,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(613,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(102,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(102,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(46); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(727); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(534); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(618); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(443); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + } + + @Test + public void test10() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(471); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + theQueue.enqueue(427); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + theQueue.enqueue(449); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + theQueue.enqueue(175); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(471,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(125); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(716); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(117); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(88); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(601); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(442); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(272); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(427,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(962); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(893); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(19); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(788); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(291); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(449,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(175,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(175,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(125,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(125,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(600); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(331); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(390); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(98); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(701); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(998); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(716,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(117,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(88,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(601,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(442,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(272,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(962,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(893,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(19,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(788,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(291,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(600,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(331,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(390,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(98,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(701,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(998,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(98); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(990); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(29); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(355); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(129); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(98,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(990,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(29,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(355,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(129,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(146); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(146,theQueue.front().intValue()); + theQueue.enqueue(818); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(146,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(146,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(980); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(884); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(399); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(107); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(0); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(373); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(475); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(818,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(980,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(980,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(884,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(399,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(107,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(0,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(373,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(475,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(563); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(563,theQueue.front().intValue()); + theQueue.enqueue(371); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(563,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(563,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(371,theQueue.front().intValue()); + theQueue.enqueue(833); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(371,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(371,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(833,theQueue.front().intValue()); + theQueue.enqueue(744); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(833,theQueue.front().intValue()); + theQueue.enqueue(644); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(833,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(833,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(744,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(644,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(592); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(592,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(592,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(878); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(878,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(878,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(66); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(66,theQueue.front().intValue()); + theQueue.enqueue(7); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(66,theQueue.front().intValue()); + theQueue.enqueue(216); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(66,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(66,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(275); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(938); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(954); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(505); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(537); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(600); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(7,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + theQueue.enqueue(521); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + theQueue.enqueue(558); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + theQueue.enqueue(486); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(216,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + theQueue.enqueue(554); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + theQueue.enqueue(212); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + theQueue.enqueue(648); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(275,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(938,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(954,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(505,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(537,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(600,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(521,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(558,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(486,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(554,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(212,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(648,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(849); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(849,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(849,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(910); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(244); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(543); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(440); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(468); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(935); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(625); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(910,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(244,theQueue.front().intValue()); + theQueue.enqueue(702); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(244,theQueue.front().intValue()); + theQueue.enqueue(236); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(244,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(244,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(543,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(440,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(468,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(935,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(625,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(702,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(236,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(243); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + theQueue.enqueue(120); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + theQueue.enqueue(952); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(243,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(120,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(952,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(282); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + theQueue.enqueue(648); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + theQueue.enqueue(188); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + theQueue.enqueue(339); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + } + +} diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/README.TXT b/Quellcodes/Alg_DS_Queue/01_queue_roh/README.TXT new file mode 100644 index 0000000..691e98b Binary files /dev/null and b/Quellcodes/Alg_DS_Queue/01_queue_roh/README.TXT differ diff --git a/Quellcodes/Alg_DS_Queue/01_queue_roh/package.bluej b/Quellcodes/Alg_DS_Queue/01_queue_roh/package.bluej new file mode 100644 index 0000000..23acc84 --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/01_queue_roh/package.bluej @@ -0,0 +1,76 @@ +#BlueJ package file +dependency1.from=ArrayQueueTester +dependency1.to=ArrayQueue +dependency1.type=UsesDependency +dependency2.from=QueueTester +dependency2.to=Queue +dependency2.type=UsesDependency +dependency3.from=LinkedQueueTester +dependency3.to=LinkedQueue +dependency3.type=UsesDependency +editor.fx.0.height=889 +editor.fx.0.width=816 +editor.fx.0.x=53 +editor.fx.0.y=88 +objectbench.height=120 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.746 +package.editor.height=366 +package.editor.width=649 +package.editor.x=807 +package.editor.y=149 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=3 +package.numTargets=6 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=ArrayQueue +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=20 +target1.y=170 +target2.height=50 +target2.name=ArrayQueueTester +target2.showInterface=false +target2.type=UnitTestTargetJunit4 +target2.width=140 +target2.x=100 +target2.y=300 +target3.height=50 +target3.name=LinkedQueue +target3.showInterface=false +target3.type=ClassTarget +target3.width=130 +target3.x=370 +target3.y=160 +target4.height=50 +target4.name=QueueTester +target4.showInterface=false +target4.type=AbstractTarget +target4.width=100 +target4.x=220 +target4.y=210 +target5.height=50 +target5.name=LinkedQueueTester +target5.showInterface=false +target5.type=UnitTestTargetJunit4 +target5.width=140 +target5.x=280 +target5.y=300 +target6.height=50 +target6.name=Queue +target6.showInterface=false +target6.type=AbstractTarget +target6.width=90 +target6.x=210 +target6.y=40 diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/ArrayQueue.java b/Quellcodes/Alg_DS_Queue/02_queue_loes/ArrayQueue.java new file mode 100644 index 0000000..c34e0cd --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/ArrayQueue.java @@ -0,0 +1,124 @@ + +/** + * Queue basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayQueue extends Queue +{ + /** + * Die Nutzdaten + */ + private Object[] daten; + + /** + * Der Index des ersten Wertes + */ + private int first; + + /** + * Der nächste freie Index + */ + private int last; + + /** + * Erzeugt eine neue, leere Queue + */ + public ArrayQueue() + { + daten = new Object[10]; + first = 0; + last = 0; + } + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public void enqueue(T x) + { + daten[last] = x; + last++; + if (last == daten.length) + { + last = 0; + } + if (last == first) // Vergrößerung nötig + { + Object[] tmp = new Object[daten.length*2]; + System.arraycopy(daten, first, tmp, 0, daten.length - first); + System.arraycopy(daten, 0, tmp, daten.length - first, first); + first = 0; + last = daten.length; + daten = tmp; + } + } + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public T front() + { + if (isEmpty()) + { + return null; + } + return (T)daten[first]; + } + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public T dequeue() + { + T x = null; + if (!isEmpty()) + { + x = (T)daten[first]; + first++; + if (first == daten.length) + { + first = 0; + } + } + return x; + } + + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public boolean isEmpty() + { + return first == last; + } + + /** + * Gibt die Queue in String-Form aus. + * @return Die String-Repräsentation der Queue + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + for (int i = first; i < (last < first ? daten.length : last); i++) + { + if (i != first) + { + b.append(", "); + } + b.append(daten[i]); + } + if (last < first) + { + for (int i = 0; i < last; i++) + { + b.append(", " + daten[i]); + } + } + return "< " + b.toString() + " <"; + } +} diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/ArrayQueueTester.java b/Quellcodes/Alg_DS_Queue/02_queue_loes/ArrayQueueTester.java new file mode 100644 index 0000000..0067c37 --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/ArrayQueueTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für die ArrayQueue + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayQueueTester extends QueueTester +{ + @Before + public void setUp() + { + theQueue = new ArrayQueue(); + } +} diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/LinkedQueue.java b/Quellcodes/Alg_DS_Queue/02_queue_loes/LinkedQueue.java new file mode 100644 index 0000000..73c8fe4 --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/LinkedQueue.java @@ -0,0 +1,137 @@ + +/** + * Eine Queue basierend auf einer verketteten Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedQueue extends Queue +{ + /** + * Der vorderste Wert der Queue + */ + private Listenknoten first; + + /** + * Der hinterste Wert der Queue + */ + private Listenknoten last; + + /** + * Erzeugt eine neue, leere Queue + */ + public LinkedQueue() + { + first = null; + last = null; + } + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public T front() + { + if (first != null) + { + return first.daten; + } + return null; + } + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public T dequeue() + { + T w = null; + if (first != null) + { + w = first.daten; + first = first.nachfolger; + if (first == null) + { + last = null; + } + } + return w; + } + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public void enqueue(T x) + { + if (first == null) + { + first = new Listenknoten(x, null); + last = first; + } + else + { + last.nachfolger = new Listenknoten(x, null); + last = last.nachfolger; + } + } + + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public boolean isEmpty() + { + return first == null && last == null; + } + + /** + * Ein Listenknoten, wie er bei den verketteten Listen verwendet wurde. + * Diesmal allerdings als innere Klasse + */ + private class Listenknoten + { + /** + * Der Datenwert des Listenknotens + */ + public T daten; + /** + * Der Nachfolger des Listenknotens + */ + public Listenknoten nachfolger; + + /** + * Erzeugt einen neuen Listenknoten + * + * @param daten Der Datenwert des Knotens + * @param nachfolger Der Nachfolger des Knotens + */ + public Listenknoten(T daten, Listenknoten nachfolger) + { + this.daten = daten; + this.nachfolger = nachfolger; + } + } + + /** + * Gibt die Queue in String-Form aus. + * @return Die String-Repräsentation der Queue + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + Listenknoten k = first; + while(k != null) + { + if (b.length() > 0) + { + b.append(", "); + } + b.append(k.daten); + k = k.nachfolger; + } + return "< " + b.toString() + " <"; + } +} + \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/LinkedQueueTester.java b/Quellcodes/Alg_DS_Queue/02_queue_loes/LinkedQueueTester.java new file mode 100644 index 0000000..186e60b --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/LinkedQueueTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für die LinkedQueue + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedQueueTester extends QueueTester +{ + @Before + public void setUp() + { + theQueue = new LinkedQueue(); + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/Queue.java b/Quellcodes/Alg_DS_Queue/02_queue_loes/Queue.java new file mode 100644 index 0000000..7eba60d --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/Queue.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Queues + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Queue +{ + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public abstract void enqueue(T x); + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public abstract T dequeue(); + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public abstract T front(); +} diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/QueueTester.java b/Quellcodes/Alg_DS_Queue/02_queue_loes/QueueTester.java new file mode 100644 index 0000000..7ce415c --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/QueueTester.java @@ -0,0 +1,5004 @@ +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Die Test-Klasse QueueTester. + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class QueueTester +{ + protected Queue theQueue; + + @Test + public void test01() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(25); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(77); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(621); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(672); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(601); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(975); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(254); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(385); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(493); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(322); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(581); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + theQueue.enqueue(432); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(25,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(25,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(77,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(77,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(621,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(672,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(601,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(975,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(254,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(385,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(493,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(322,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(581,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(432,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(979); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(301); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(352); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(533); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + theQueue.enqueue(146); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(979,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(979,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(301,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(352,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(533,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(146,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(406); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(406,theQueue.front().intValue()); + theQueue.enqueue(786); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(406,theQueue.front().intValue()); + theQueue.enqueue(897); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(406,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(406,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(241); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(999); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + theQueue.enqueue(808); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(786,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(786,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(897,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(241,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(999,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(808,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(47); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(47,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(47,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(312); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(312,theQueue.front().intValue()); + theQueue.enqueue(498); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(312,theQueue.front().intValue()); + theQueue.enqueue(551); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(312,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(312,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(498,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(551,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(69); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + theQueue.enqueue(863); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(69,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + theQueue.enqueue(615); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(863,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(924,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(281); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(293); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(928); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + theQueue.enqueue(86); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(615,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(615,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(281,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(293,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(928,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(86,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(100); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(899); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(100,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(899,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(340); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(340,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(340,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(13); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(13,theQueue.front().intValue()); + theQueue.enqueue(596); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(13,theQueue.front().intValue()); + theQueue.enqueue(950); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(13,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(13,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(596,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(950,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(169); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(169,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(169,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(52); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(574); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(52,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(574,theQueue.front().intValue()); + theQueue.enqueue(792); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(574,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(574,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(678); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(348); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(597); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(597); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(632); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(578); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(480); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + theQueue.enqueue(682); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(792,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(792,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(276); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(731); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(941); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(55); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(897); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(864); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(640); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + theQueue.enqueue(571); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(678,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(678,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(348,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(597,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(597,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(632,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(578,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(480,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(682,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(276,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(731,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(941,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(55,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(897,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(864,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(640,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(571,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(940); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(926); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(388); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(940,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(926,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(388,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(869); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(869,theQueue.front().intValue()); + theQueue.enqueue(109); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(869,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(869,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(109,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(33); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(33,theQueue.front().intValue()); + theQueue.enqueue(711); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(33,theQueue.front().intValue()); + theQueue.enqueue(253); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(33,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(33,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + theQueue.enqueue(280); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + theQueue.enqueue(899); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + theQueue.enqueue(453); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(711,theQueue.front().intValue()); + } + + @Test + public void test02() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(295); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(295,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(295,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(6); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(954); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(907); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(857); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(164); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(668); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(6,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(869); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(353); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(83); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + theQueue.enqueue(730); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(954,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(954,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + theQueue.enqueue(766); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + theQueue.enqueue(405); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + theQueue.enqueue(791); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(907,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(907,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(857,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(857,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(503); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(899); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(880); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(845); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + theQueue.enqueue(137); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(164,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(164,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(668,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(668,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(869,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(869,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(889); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(461); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(143); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(242); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(986); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + theQueue.enqueue(491); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(483,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(353,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(83,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(730,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(766,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(405,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(791,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(503,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(899,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(880,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(845,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(137,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(889,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(461,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(143,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(242,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(986,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(491,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(35); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(35,theQueue.front().intValue()); + theQueue.enqueue(473); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(35,theQueue.front().intValue()); + theQueue.enqueue(870); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(35,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(35,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(473,theQueue.front().intValue()); + theQueue.enqueue(332); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(473,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(473,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(870,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(870,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(332,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(851); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(851,theQueue.front().intValue()); + theQueue.enqueue(752); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(851,theQueue.front().intValue()); + theQueue.enqueue(756); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(851,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(851,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(752,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(756,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(970); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(970,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(970,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(227); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(227,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(227,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(453); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(453,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(453,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(584); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(584,theQueue.front().intValue()); + theQueue.enqueue(882); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(584,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(584,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(882,theQueue.front().intValue()); + theQueue.enqueue(134); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(882,theQueue.front().intValue()); + theQueue.enqueue(514); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(882,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(882,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(134,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(134,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(514,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(79); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(990); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(574); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(146); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(967); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + theQueue.enqueue(597); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(79,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(79,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(990,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(990,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(574,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(146,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(967,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(597,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(725); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(725,theQueue.front().intValue()); + theQueue.enqueue(482); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(725,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(725,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + theQueue.enqueue(662); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(482,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(662,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(662,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(482); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + theQueue.enqueue(643); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(482,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(482,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(643,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(862); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(862,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(862,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(573); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(573,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(573,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(845); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(845,theQueue.front().intValue()); + theQueue.enqueue(109); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(845,theQueue.front().intValue()); + theQueue.enqueue(326); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(845,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(845,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + theQueue.enqueue(404); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + theQueue.enqueue(398); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + theQueue.enqueue(251); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(109,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(109,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(326,theQueue.front().intValue()); + theQueue.enqueue(836); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(326,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(326,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(404,theQueue.front().intValue()); + theQueue.enqueue(71); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(404,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(404,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(398,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(398,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(251,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(836,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(71,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(166); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(166,theQueue.front().intValue()); + theQueue.enqueue(642); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(166,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(166,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(642,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(642,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(690); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(690,theQueue.front().intValue()); + } + + @Test + public void test03() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(474); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(708); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(120); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(368); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(844); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(816); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(474,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(708,theQueue.front().intValue()); + theQueue.enqueue(100); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(708,theQueue.front().intValue()); + theQueue.enqueue(497); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(708,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(708,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(120,theQueue.front().intValue()); + theQueue.enqueue(491); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(120,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(120,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(368,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(368,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(844,theQueue.front().intValue()); + theQueue.enqueue(504); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(844,theQueue.front().intValue()); + theQueue.enqueue(647); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(844,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(844,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(816,theQueue.front().intValue()); + theQueue.enqueue(219); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(816,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(816,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(100,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(497,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(491,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(504,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(647,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(219,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(474); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(328); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(429); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + theQueue.enqueue(890); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(474,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(474,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(328,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(429,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(890,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(863); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(863,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(863,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(426); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(426,theQueue.front().intValue()); + theQueue.enqueue(699); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(426,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(426,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(699,theQueue.front().intValue()); + theQueue.enqueue(988); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(699,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(699,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(988,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(564,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(912); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(912,theQueue.front().intValue()); + theQueue.enqueue(0); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(912,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(912,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(912,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(0,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(197); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(197,theQueue.front().intValue()); + theQueue.enqueue(940); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(197,theQueue.front().intValue()); + theQueue.enqueue(229); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(197,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(197,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(231); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + theQueue.enqueue(722); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(940,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(940,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(68); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(977); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(294); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(670); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(494); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(243); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(169); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(159); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(189); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(623); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(229,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(229,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(231,theQueue.front().intValue()); + theQueue.enqueue(544); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(231,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(231,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(722,theQueue.front().intValue()); + theQueue.enqueue(922); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(722,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(722,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(68,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(68,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(977,theQueue.front().intValue()); + theQueue.enqueue(237); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(977,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(977,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(515); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(886); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(930); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + theQueue.enqueue(874); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(294,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(294,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + theQueue.enqueue(144); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + theQueue.enqueue(185); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + theQueue.enqueue(796); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(670,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(670,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(494,theQueue.front().intValue()); + theQueue.enqueue(833); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(494,theQueue.front().intValue()); + theQueue.enqueue(395); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(494,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(494,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(243,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(169,theQueue.front().intValue()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(169,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(169,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(159,theQueue.front().intValue()); + theQueue.enqueue(679); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(159,theQueue.front().intValue()); + theQueue.enqueue(940); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(159,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(159,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(189,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(831); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(654); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(5); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(275); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + theQueue.enqueue(675); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(623,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(623,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(544,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(922,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(237,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(515,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(886,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(930,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(874,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(144,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(185,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(796,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(833,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(395,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(679,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(940,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(831,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(654,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(5,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(275,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(675,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(383); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(383,theQueue.front().intValue()); + theQueue.enqueue(974); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(383,theQueue.front().intValue()); + theQueue.enqueue(99); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(383,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(383,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(974,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(99,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(635); + assertFalse(theQueue.isEmpty()); + + assertNotNull(theQueue.front()); + assertEquals(635,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(635,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(504); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + theQueue.enqueue(896); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + theQueue.enqueue(77); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + theQueue.enqueue(312); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(504,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(504,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(896,theQueue.front().intValue()); + } + + @Test + public void test04() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(723); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(723,theQueue.front().intValue()); + theQueue.enqueue(537); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(723,theQueue.front().intValue()); + theQueue.enqueue(78); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(723,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(723,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(537,theQueue.front().intValue()); + theQueue.enqueue(386); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(537,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(537,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(537,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(78,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(386,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(569); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(569,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(569,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(906,theQueue.front().intValue()); + theQueue.enqueue(192); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(906,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(192,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(665); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(665,theQueue.front().intValue()); + theQueue.enqueue(398); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(665,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(665,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(398,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(398,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(23); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(970); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(656); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(235); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(797); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(210); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + theQueue.enqueue(59); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(23,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(23,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(970,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(656,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(235,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(797,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(210,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(59,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(506); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(938); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(135); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(126); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + theQueue.enqueue(573); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(506,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(506,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(938,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(938,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + theQueue.enqueue(920); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + theQueue.enqueue(412); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + theQueue.enqueue(5); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(135,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(135,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(126,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(126,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(573,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(920,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(412,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(5,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(145); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(616); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(885); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(74); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(843); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + theQueue.enqueue(926); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(145,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(145,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(616,theQueue.front().intValue()); + theQueue.enqueue(520); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(616,theQueue.front().intValue()); + theQueue.enqueue(24); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(616,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(616,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(885,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(74,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(843,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(926,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(520,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(24,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(898); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + theQueue.enqueue(547); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + theQueue.enqueue(621); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + theQueue.enqueue(170); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(898,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(898,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(547,theQueue.front().intValue()); + theQueue.enqueue(537); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(547,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(547,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(621,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(621,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(170,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(537,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(936); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(239); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(114); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(165); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(420); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + theQueue.enqueue(362); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(936,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(936,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(239,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(114,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(165,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(420,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(362,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(344); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(284); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(292); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(572); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(306); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(557); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + theQueue.enqueue(321); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(344,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(344,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(284,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(292,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(572,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(306,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(557,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(321,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(605); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(605,theQueue.front().intValue()); + theQueue.enqueue(387); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(605,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(605,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(387,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(387,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(509); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(509,theQueue.front().intValue()); + theQueue.enqueue(498); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(509,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(509,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(374); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(421); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(604); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(555); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(1); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(881); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + theQueue.enqueue(372); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(498,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(498,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(374,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(374,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + theQueue.enqueue(685); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + theQueue.enqueue(187); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + theQueue.enqueue(498); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(421,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(421,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(604,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(604,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(659); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(62); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(868); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(34); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + theQueue.enqueue(799); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + } + + @Test + public void test05() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(302); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(302,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(302,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(376); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + theQueue.enqueue(858); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + theQueue.enqueue(488); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + theQueue.enqueue(673); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(376,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(376,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(374); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(557); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(766); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(914); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + theQueue.enqueue(447); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(858,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(858,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + theQueue.enqueue(390); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + theQueue.enqueue(892); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(488,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(488,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(434); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(96); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(642); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(144); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(664); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(751); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(492); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(339); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(801); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(244); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(806); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(612); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + theQueue.enqueue(511); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(673,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(673,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(374,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(557,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(766,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(914,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(447,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(390,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(892,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(434,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(96,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(642,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(144,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(664,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(751,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(492,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(339,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(801,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(244,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(806,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(612,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(511,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(821); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(821,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(564); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(564,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(564,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(60); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(60,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(60,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(514); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(514,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(514,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(727); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(727,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(727,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(377); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(846); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(990); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(904); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + theQueue.enqueue(271); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(377,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(377,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(846,theQueue.front().intValue()); + theQueue.enqueue(732); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(846,theQueue.front().intValue()); + theQueue.enqueue(37); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(846,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(846,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(990,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(904,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(271,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(732,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(37,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(967); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(62); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(661); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(139); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(924); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + theQueue.enqueue(106); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(967,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(967,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(62,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(62,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(661,theQueue.front().intValue()); + theQueue.enqueue(64); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(661,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(661,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(139,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(924,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(106,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(64,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(848); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(848,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(848,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(864); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(864,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(864,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(864); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(864,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(864,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(804); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(804,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(804,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(37); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(37,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + theQueue.enqueue(510); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(510,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(706); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(978); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(769); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(863); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(516); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + theQueue.enqueue(783); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(706,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(706,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(276); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(74); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(311); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + theQueue.enqueue(350); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(978,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(978,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(769,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(863,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(516,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(783,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(276,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(74,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(311,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(350,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(773); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(773,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(773,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(424); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(424,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(416); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(416,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(416,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(420); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(837); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(319); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(879); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + theQueue.enqueue(142); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(420,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(420,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(837,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(837,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(319,theQueue.front().intValue()); + theQueue.enqueue(464); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(319,theQueue.front().intValue()); + } + + @Test + public void test06() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(212); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(212,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(212,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(555); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(555,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(721); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(721,theQueue.front().intValue()); + theQueue.enqueue(205); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(721,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(721,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + theQueue.enqueue(896); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + theQueue.enqueue(667); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + theQueue.enqueue(343); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(205,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(205,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(896,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(896,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(667,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(343,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(932); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(834); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(580); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(120); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(622); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(219); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(133); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(902); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(857); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(898); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + theQueue.enqueue(505); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(932,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(932,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(834,theQueue.front().intValue()); + theQueue.enqueue(156); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(834,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(834,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(580,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(120,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(622,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(219,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(133,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(902,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(857,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(898,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(505,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(156,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(431); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(431,theQueue.front().intValue()); + theQueue.enqueue(578); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(431,theQueue.front().intValue()); + theQueue.enqueue(611); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(431,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(431,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(578,theQueue.front().intValue()); + theQueue.enqueue(542); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(578,theQueue.front().intValue()); + theQueue.enqueue(838); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(578,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(578,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(237); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(387); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(946); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(311); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(404); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(800); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + theQueue.enqueue(433); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(611,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(611,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(542,theQueue.front().intValue()); + theQueue.enqueue(215); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(542,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(542,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(838,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(838,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(237,theQueue.front().intValue()); + theQueue.enqueue(542); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(237,theQueue.front().intValue()); + theQueue.enqueue(424); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(237,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(237,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(387,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(946,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(311,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(404,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(800,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(433,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(215,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(542,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(424,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(991); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(991,theQueue.front().intValue()); + theQueue.enqueue(204); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(991,theQueue.front().intValue()); + theQueue.enqueue(695); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(991,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(991,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(204,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(695,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(6); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(51); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + theQueue.enqueue(261); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(6,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(6,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(51,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(261,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(753); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(753,theQueue.front().intValue()); + theQueue.enqueue(292); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(753,theQueue.front().intValue()); + theQueue.enqueue(34); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(753,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(753,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(292,theQueue.front().intValue()); + theQueue.enqueue(744); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(292,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(292,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(34,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(34,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(744,theQueue.front().intValue()); + theQueue.enqueue(790); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(744,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(744,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(790,theQueue.front().intValue()); + theQueue.enqueue(579); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(790,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(790,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(579,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(579,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(579,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(335); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(335,theQueue.front().intValue()); + theQueue.enqueue(460); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(335,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(335,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(460,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(614); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(874); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(375); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(908); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + theQueue.enqueue(651); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(614,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(614,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(356); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(661); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(113); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + theQueue.enqueue(200); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(874,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(874,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(375,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(908,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(651,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(356,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(661,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(113,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(200,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(598); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(29); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(960); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(147); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(713); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(820); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(598,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(29,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(960,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(147,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(713,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(820,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(562); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(562,theQueue.front().intValue()); + theQueue.enqueue(411); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(562,theQueue.front().intValue()); + theQueue.enqueue(399); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(562,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(562,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(411,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(399,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(334); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(334,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(334,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(778); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(778,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(778,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(386); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(386,theQueue.front().intValue()); + theQueue.enqueue(613); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(386,theQueue.front().intValue()); + } + + @Test + public void test07() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(642); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(642,theQueue.front().intValue()); + theQueue.enqueue(189); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(642,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(642,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + theQueue.enqueue(68); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + theQueue.enqueue(533); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(189,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(68,theQueue.front().intValue()); + theQueue.enqueue(4); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(68,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(68,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(533); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(747); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(533,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(345); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(370); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(531); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(217); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(569); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(902); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(712); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(569); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + theQueue.enqueue(852); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(4,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(4,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(27); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(833); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + theQueue.enqueue(839); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(533,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(533,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(747,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(345,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(370,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(531,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(217,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(569,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(902,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(712,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(569,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(852,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(27,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(833,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(839,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(152); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + theQueue.enqueue(646); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + theQueue.enqueue(405); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + theQueue.enqueue(226); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(152,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(152,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(646,theQueue.front().intValue()); + theQueue.enqueue(66); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(646,theQueue.front().intValue()); + theQueue.enqueue(206); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(646,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(646,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + theQueue.enqueue(495); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + theQueue.enqueue(152); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + theQueue.enqueue(454); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(405,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(405,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(331); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(736); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + theQueue.enqueue(627); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(226,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(226,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(66,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(206,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(495,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(152,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(454,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(331,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(736,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(627,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(350); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(350,theQueue.front().intValue()); + theQueue.enqueue(37); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(350,theQueue.front().intValue()); + theQueue.enqueue(277); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(350,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(350,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + theQueue.enqueue(667); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(37,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(37,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(277,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(667,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(712); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(712,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(712,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(566); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(566,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(566,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(853); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(853,theQueue.front().intValue()); + theQueue.enqueue(12); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(853,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(853,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(12,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(179); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(179,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(179,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(767); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(927); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(397); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(961); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(423); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + theQueue.enqueue(781); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(767,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(767,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(927,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(397,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(961,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(423,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(781,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(555); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(555,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(555,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(634); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(634,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(634,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(525); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(525,theQueue.front().intValue()); + theQueue.enqueue(185); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(525,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(525,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(185,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(832); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(832,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(832,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(52); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(307); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(306); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(837); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + theQueue.enqueue(902); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(52,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(52,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(307,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(306,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(837,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(902,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(945); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(945,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(945,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(178); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(107); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(606); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(452); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + theQueue.enqueue(973); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(178,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(178,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(107,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(606,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(452,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(973,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(635); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(635,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(635,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(391); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(391,theQueue.front().intValue()); + theQueue.enqueue(311); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(391,theQueue.front().intValue()); + theQueue.enqueue(989); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(391,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(391,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(311,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(311,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(989,theQueue.front().intValue()); + theQueue.enqueue(856); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(989,theQueue.front().intValue()); + } + + @Test + public void test08() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(493); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(288); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(72); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(576); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(26); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + theQueue.enqueue(502); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(493,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(493,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(288,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(72,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(576,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(26,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(502,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(69); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + theQueue.enqueue(908); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + theQueue.enqueue(717); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(69,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(69,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(908,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(717,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(513); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(101); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(158); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(876); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(459); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(72); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(928); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(91); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + theQueue.enqueue(911); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(513,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(513,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + theQueue.enqueue(558); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + theQueue.enqueue(103); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + theQueue.enqueue(67); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(101,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(101,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(158,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(876,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(459,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(72,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(928,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(91,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(911,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(558,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(103,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(67,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(515); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(515,theQueue.front().intValue()); + theQueue.enqueue(797); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(515,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(515,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(797,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(821); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(425); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(266); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(598); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + theQueue.enqueue(332); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(821,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(821,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(41); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(848); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(531); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(478); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(794); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + theQueue.enqueue(834); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(425,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(425,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(266,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(598,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(332,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(41,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(848,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(531,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(478,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(794,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(834,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(138); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(138,theQueue.front().intValue()); + theQueue.enqueue(794); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(138,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(138,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(794,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(794,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(986); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(986,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(986,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(904); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + theQueue.enqueue(297); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + theQueue.enqueue(824); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + theQueue.enqueue(999); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(904,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(904,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(297,theQueue.front().intValue()); + theQueue.enqueue(645); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(297,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(297,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(824,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(999,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(645,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(839); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(521); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(581); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(915); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + theQueue.enqueue(199); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(839,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(839,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(521,theQueue.front().intValue()); + theQueue.enqueue(474); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(521,theQueue.front().intValue()); + theQueue.enqueue(655); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(521,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(521,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(581,theQueue.front().intValue()); + theQueue.enqueue(373); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(581,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(581,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + theQueue.enqueue(231); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + theQueue.enqueue(409); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + theQueue.enqueue(582); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(915,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(915,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(49); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(880); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(767); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(242); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + theQueue.enqueue(771); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(199,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(199,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(474,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(655,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(373,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(231,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(409,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(582,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(49,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(880,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(767,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(242,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(771,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(48); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(48,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(48,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(0); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(25); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(869); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(191); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + theQueue.enqueue(4); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(0,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(0,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(25,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(869,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(191,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(4,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(909); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + theQueue.enqueue(947); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + theQueue.enqueue(935); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(909,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(909,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(947,theQueue.front().intValue()); + theQueue.enqueue(816); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(947,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(947,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(935,theQueue.front().intValue()); + theQueue.enqueue(853); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(935,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(935,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(816,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(853,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(411); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(411,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(411,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(206); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + theQueue.enqueue(511); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + theQueue.enqueue(122); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + theQueue.enqueue(499); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(206,theQueue.front().intValue()); + } + + @Test + public void test09() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(436); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(436,theQueue.front().intValue()); + theQueue.enqueue(622); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(436,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(436,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(622,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(664); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + theQueue.enqueue(114); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + theQueue.enqueue(168); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + theQueue.enqueue(259); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(664,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(664,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(114,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(168,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(259,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(747); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(724); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(255); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(638); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(8); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + theQueue.enqueue(455); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(747,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(747,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(397); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(916); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(206); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(49); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + theQueue.enqueue(347); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(724,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(724,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(255,theQueue.front().intValue()); + theQueue.enqueue(817); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(255,theQueue.front().intValue()); + theQueue.enqueue(561); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(255,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(255,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(994); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(957); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(380); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(729); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(231); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + theQueue.enqueue(473); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(638,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(638,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(8,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(455,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(397,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(916,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(206,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(49,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(347,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(817,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(561,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(994,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(957,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(380,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(729,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(231,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(473,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(886); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(886,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(886,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(27); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(27,theQueue.front().intValue()); + theQueue.enqueue(913); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(27,theQueue.front().intValue()); + theQueue.enqueue(544); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(27,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(27,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(913,theQueue.front().intValue()); + theQueue.enqueue(666); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(913,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(913,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(544,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(666,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(343); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(343,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(343,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(123); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(123,theQueue.front().intValue()); + theQueue.enqueue(867); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(123,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(123,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(867,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(808); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(497); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(580); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(949); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(356); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + theQueue.enqueue(465); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(808,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(808,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(497,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(580,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(949,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(356,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(465,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(519); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(519,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(519,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(115); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(115,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(115,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(424); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(42); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(397); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(644); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(189); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(75); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + theQueue.enqueue(45); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(424,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(424,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(42,theQueue.front().intValue()); + theQueue.enqueue(439); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(42,theQueue.front().intValue()); + theQueue.enqueue(896); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(42,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(42,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(873); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(517); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(428); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(39); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(183); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(181); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(397,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(397,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(786); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(321); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(619); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(349); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + theQueue.enqueue(504); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(644,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(644,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + theQueue.enqueue(742); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(189,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(189,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(75,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(75,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(45,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(45,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(439,theQueue.front().intValue()); + theQueue.enqueue(783); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(439,theQueue.front().intValue()); + theQueue.enqueue(786); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(439,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(439,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(896,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(896,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(873,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(517,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(428,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(39,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(183,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(181,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(786,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(321,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(619,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(349,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(504,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(742,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(783,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(786,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(613); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(613,theQueue.front().intValue()); + theQueue.enqueue(102); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(613,theQueue.front().intValue()); + theQueue.enqueue(598); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(613,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(613,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(102,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(102,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(46); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(727); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(534); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(618); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + theQueue.enqueue(443); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(598,theQueue.front().intValue()); + } + + @Test + public void test10() + { + Integer tmp; + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(471); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + theQueue.enqueue(427); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + theQueue.enqueue(449); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + theQueue.enqueue(175); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(471,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(471,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(125); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(716); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(117); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(88); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(601); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(442); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + theQueue.enqueue(272); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(427,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(427,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(962); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(893); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(19); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(788); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(483); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + theQueue.enqueue(291); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(449,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(449,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(175,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(175,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(125,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(125,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(600); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(331); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(390); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(98); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(701); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + theQueue.enqueue(998); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(716,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(716,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(117,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(88,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(601,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(442,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(272,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(962,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(893,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(19,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(788,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(483,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(291,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(600,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(331,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(390,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(98,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(701,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(998,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(98); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(990); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(29); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(355); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + theQueue.enqueue(129); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(98,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(98,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(990,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(29,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(355,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(129,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(146); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(146,theQueue.front().intValue()); + theQueue.enqueue(818); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(146,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(146,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(980); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(884); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(399); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(107); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(0); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(906); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(373); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + theQueue.enqueue(475); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(818,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(818,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(980,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(980,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(884,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(399,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(107,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(0,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(906,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(373,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(475,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(563); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(563,theQueue.front().intValue()); + theQueue.enqueue(371); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(563,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(563,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(371,theQueue.front().intValue()); + theQueue.enqueue(833); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(371,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(371,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(833,theQueue.front().intValue()); + theQueue.enqueue(744); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(833,theQueue.front().intValue()); + theQueue.enqueue(644); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(833,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(833,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(744,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(644,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(592); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(592,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(592,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(878); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(878,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(878,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(66); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(66,theQueue.front().intValue()); + theQueue.enqueue(7); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(66,theQueue.front().intValue()); + theQueue.enqueue(216); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(66,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(66,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(275); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(938); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(954); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(505); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(537); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + theQueue.enqueue(600); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(7,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(7,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + theQueue.enqueue(521); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + theQueue.enqueue(558); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + theQueue.enqueue(486); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(216,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(216,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + theQueue.enqueue(554); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + theQueue.enqueue(212); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + theQueue.enqueue(648); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(275,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(275,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(938,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(954,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(505,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(537,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(600,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(521,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(558,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(486,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(554,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(212,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(648,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(849); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(849,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(849,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(910); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(244); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(543); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(440); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(468); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(935); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + theQueue.enqueue(625); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(910,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(910,tmp.intValue()); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(244,theQueue.front().intValue()); + theQueue.enqueue(702); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(244,theQueue.front().intValue()); + theQueue.enqueue(236); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(244,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(244,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(543,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(440,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(468,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(935,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(625,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(702,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(236,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(243); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + theQueue.enqueue(120); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + theQueue.enqueue(952); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(243,theQueue.front().intValue()); + tmp = theQueue.dequeue(); + assertEquals(243,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(120,tmp.intValue()); + tmp = theQueue.dequeue(); + assertEquals(952,tmp.intValue()); + assertTrue(theQueue.isEmpty()); + assertNull(theQueue.front()); + theQueue.enqueue(282); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + theQueue.enqueue(648); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + theQueue.enqueue(188); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + theQueue.enqueue(339); + assertFalse(theQueue.isEmpty()); + assertNotNull(theQueue.front()); + assertEquals(282,theQueue.front().intValue()); + } + +} diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/README.TXT b/Quellcodes/Alg_DS_Queue/02_queue_loes/README.TXT new file mode 100644 index 0000000..e45dacd --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Stack +PROJEKTZWECK: Zwei Implementationen des ADTs Stack +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Implementieren Sie den ArrayStack oder den LinkedStack. Führen Sie dann bei den entsprechenden Tester-Klassen "Alles testen" aus. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Queue/02_queue_loes/package.bluej b/Quellcodes/Alg_DS_Queue/02_queue_loes/package.bluej new file mode 100644 index 0000000..fce77db --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/02_queue_loes/package.bluej @@ -0,0 +1,76 @@ +#BlueJ package file +dependency1.from=ArrayQueueTester +dependency1.to=ArrayQueue +dependency1.type=UsesDependency +dependency2.from=QueueTester +dependency2.to=Queue +dependency2.type=UsesDependency +dependency3.from=LinkedQueueTester +dependency3.to=LinkedQueue +dependency3.type=UsesDependency +editor.fx.0.height=924 +editor.fx.0.width=1139 +editor.fx.0.x=59 +editor.fx.0.y=36 +objectbench.height=126 +objectbench.width=759 +package.divider.horizontal=0.6 +package.divider.vertical=0.734 +package.editor.height=360 +package.editor.width=635 +package.editor.x=807 +package.editor.y=149 +package.frame.height=600 +package.frame.width=799 +package.numDependencies=3 +package.numTargets=6 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=ArrayQueue +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=20 +target1.y=170 +target2.height=50 +target2.name=ArrayQueueTester +target2.showInterface=false +target2.type=UnitTestTargetJunit4 +target2.width=140 +target2.x=100 +target2.y=300 +target3.height=50 +target3.name=LinkedQueue +target3.showInterface=false +target3.type=ClassTarget +target3.width=130 +target3.x=370 +target3.y=160 +target4.height=50 +target4.name=QueueTester +target4.showInterface=false +target4.type=AbstractTarget +target4.width=100 +target4.x=220 +target4.y=210 +target5.height=50 +target5.name=LinkedQueueTester +target5.showInterface=false +target5.type=UnitTestTargetJunit4 +target5.width=140 +target5.x=280 +target5.y=300 +target6.height=50 +target6.name=Queue +target6.showInterface=false +target6.type=AbstractTarget +target6.width=90 +target6.x=210 +target6.y=40 diff --git a/Quellcodes/Alg_DS_Queue/readme.adoc b/Quellcodes/Alg_DS_Queue/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Queue/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Set/.gitignore b/Quellcodes/Alg_DS_Set/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/+libs/SizeOf.jar b/Quellcodes/Alg_DS_Set/01_set_roh/+libs/SizeOf.jar new file mode 100644 index 0000000..d1cc0f5 Binary files /dev/null and b/Quellcodes/Alg_DS_Set/01_set_roh/+libs/SizeOf.jar differ diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/+libs/license.txt b/Quellcodes/Alg_DS_Set/01_set_roh/+libs/license.txt new file mode 100644 index 0000000..eeb85a6 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/+libs/license.txt @@ -0,0 +1,3 @@ +Quelle: https://github.com/afeinberg/sizeof +GNU Public License 2.0 +Modifikationen von Rainer Helfrich \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/BenchmarkBase.java b/Quellcodes/Alg_DS_Set/01_set_roh/BenchmarkBase.java new file mode 100644 index 0000000..fde5186 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/BenchmarkBase.java @@ -0,0 +1,124 @@ +import java.util.*; +import net.sourceforge.sizeof.*; +import java.io.*; +import java.lang.reflect.*; + +/** + * Testet Set-Varianten auf ihre Effizenz + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class BenchmarkBase +{ + protected Set theSet; + Random zufallszahlen; + + protected BenchmarkBase() + { + zufallszahlen = new Random(); + } + + protected void init(Class c) throws Exception + { + theSet = (Set)c.newInstance(); + } + + /** + * Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + * Sollte nicht direkt aufgerufen werden. + */ + public static void main(String[] args) + { + try + { + int anzahl = Integer.parseInt(args[0]); + Class c = Class.forName(args[1]); + MeinBenchmark b = new MeinBenchmark(); + b.init(c); + Method m = b.getClass().getMethod(args[2], new Class[]{int.class}); + m.invoke(b, new Object[]{anzahl}); + System.out.println("@"+SizeOf.deepSizeOf((Object)b.theSet)+"@"); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + } + + /** + * Führt einen Laufzeittest aus. Wiederholt den Test 100 mal, um Ausreißer zu vermeiden. + * Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Laufzeit des Tests in Mikrosekunden (µs) + */ + protected static int laufzeitTest(String typ, String methode, int anzahl) + { + try + { + Class c = Class.forName(typ); + MeinBenchmark b = new MeinBenchmark(); + final int DURCHGAENGE = 100; + long totalTime = 0; + for (int i = 0; i < DURCHGAENGE; i++) + { + b.init(c); + Method m = b.getClass().getMethod(methode, new Class[]{int.class}); + long vorher = System.nanoTime(); + m.invoke(b, new Object[]{anzahl}); + long nachher = System.nanoTime(); + totalTime += (nachher - vorher) / 1000; + } + return (int)(totalTime / DURCHGAENGE); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } + + /** + * Führt einen Speichertest aus. Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Größe der Set in Bytes, nachdem die Testmethode ausgeführt wurde + */ + protected static int speicherTest(String typ, String methode, int anzahl) + { + try + { + Process process = new ProcessBuilder("java","-javaagent:./+libs/SizeOf.jar", MeinBenchmark.class.getName(), ""+anzahl, typ, methode).start(); + InputStream is = process.getInputStream(); + InputStreamReader isr = new InputStreamReader(is); + BufferedReader br = new BufferedReader(isr); + String line; + + StringBuilder sb = new StringBuilder(); + while ((line = br.readLine()) != null) { + sb.append(line); + } + String strOut = sb.toString(); + int idx = strOut.indexOf("@"); + if (idx < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int idx2 = strOut.indexOf("@", idx+1); + if (idx2 < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int n = Integer.parseInt(strOut.substring(idx+1, idx2)); + return n; + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } +} diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/MeinBenchmark.java b/Quellcodes/Alg_DS_Set/01_set_roh/MeinBenchmark.java new file mode 100644 index 0000000..07acde5 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/MeinBenchmark.java @@ -0,0 +1,59 @@ + +/** + * Führt Leistungstests mit verschiedenen Set-Implementationen aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class MeinBenchmark extends BenchmarkBase +{ + //# Die Klassen SetVarianteA, SetVarianteB und SetVarianteC sind drei verschiedene Implementationen + //# des ADTs Set: Mit ArrayList, mit Bitvektor und als Hashtable. + //# Sie verhalten sich logisch gleich, zeigen aber verschiedene Eigenschaften in Bezug auf + //# Laufzeit und Speicherbedarf (vgl. Unterricht). + //# Konstruieren Sie Testfälle, mit denen man den Unterschied der Implementationsvarianten + //# erkennen kann. + //# Rufen Sie die Methoden speicherTestAusfuehren bzw. laufzeitTestAusfuehren auf, + //# um die Messergebnisse zu sehen. + + public void meinTest(int anzahl) + { + //# TODO: Konstruieren Sie einen Testfall, um herauszufinden, welche Implementation verwendet wird. + //# Der Parameter anzahl entspricht der Variablen anzahl in der Methode speicherTestAusfuehren bzw. laufzeitTestAusfuehren + //# Sie können die Methoden des Objekts theSet (ein Set-Objekt) verwenden. + for (int i = 0; i < anzahl; i++) + { + theSet.einfuegen(i); + } + } + + /** + * Führt einen Speichertest mit z.B. 100 Elementen aus und gibt das Ergebnis auf der Konsole aus. + */ + public static void speicherTestAusfuehren() + { + int anzahl = 100; + String methodenName = "meinTest"; + // Die Variable methodenName muss einer statischen Methode in dieser Klasse entsprechen + int sizeA = speicherTest("SetVarianteA", methodenName, anzahl); + int sizeB = speicherTest("SetVarianteB", methodenName, anzahl); + int sizeC = speicherTest("SetVarianteC", methodenName, anzahl); + System.out.println(String.format("%d Zahlen; SetVarianteA: %d Bytes; SetVarianteB: %d Bytes; SetVarianteC: %d Bytes", + anzahl, sizeA, sizeB, sizeC)); + } + + /** + * Führt einen Laufzeittest mit z.B. 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus. + */ + public static void laufzeitTestAusfuehren() + { + int anzahl = 1000; + String methodenName = "meinTest"; + // Die Variable methodenName muss einer statischen Methode in dieser Klasse entsprechen + long timeA = laufzeitTest("SetVarianteA", methodenName, anzahl); + long timeB = laufzeitTest("SetVarianteB", methodenName, anzahl); + long timeC = laufzeitTest("SetVarianteC", methodenName, anzahl); + System.out.println(String.format("%d Zahlen; SetVarianteA: %d µs; SetVarianteB: %d µs; SetVarianteC: %d µs", + anzahl, timeA, timeB, timeC)); + } +} diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/README.TXT b/Quellcodes/Alg_DS_Set/01_set_roh/README.TXT new file mode 100644 index 0000000..fb73768 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Set-Benchmark +PROJEKTZWECK: Konstruieren Sie einen Benchmark, um herauszufinden, um welche Implementation es sich bei einer Set handelt. +VERSION oder DATUM: November 2020 +WIE IST DAS PROJEKT ZU STARTEN: Nachdem Sie in der Methode meinTest der Klasse MeinBenchmark einen Test definiert haben, rufen Sie eine der statischen Methoden speicherTestAusfuehren() oder laufzeitTestAusfuehren() auf. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/BenchmarkBase.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/BenchmarkBase.html new file mode 100644 index 0000000..8632eab --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/BenchmarkBase.html @@ -0,0 +1,307 @@ + + + + + +BenchmarkBase + + + + + + + + + +
+
+

Class BenchmarkBase

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • BenchmarkBase
      • +
    +
    • +
+
+
    +
  • +
    +
    public class BenchmarkBase
+extends java.lang.Object
    +
    Testet Set-Varianten auf ihre Effizenz
    +
    +
    Version:
    +
    November 2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Summary

      + + + + + + + + + + + + + + + + + +
      Fields 
      Modifier and TypeFieldDescription
      protected SettheSet 
      (package private) java.util.Randomzufallszahlen 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + + +
      Constructors 
      ModifierConstructorDescription
      protected BenchmarkBase() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected voidinit​(java.lang.Class c) 
      protected static intlaufzeitTest​(java.lang.String typ, + java.lang.String methode, + int anzahl) +
      Führt einen Laufzeittest aus.
      +
      static voidmain​(java.lang.String[] args) +
      Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen.
      +
      protected static intspeicherTest​(java.lang.String typ, + java.lang.String methode, + int anzahl) +
      Führt einen Speichertest aus.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        theSet

        +
        protected Set theSet
        +
        • +
      + + + +
        +
      • +

        zufallszahlen

        +
        java.util.Random zufallszahlen
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BenchmarkBase

        +
        protected BenchmarkBase()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        init

        +
        protected void init​(java.lang.Class c)
+             throws java.lang.Exception
        +
        +
        Throws:
        +
        java.lang.Exception
        +
        +
        • +
      + + + +
        +
      • +

        main

        +
        public static void main​(java.lang.String[] args)
        +
        Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + Sollte nicht direkt aufgerufen werden.
        +
        • +
      + + + +
        +
      • +

        laufzeitTest

        +
        protected static int laufzeitTest​(java.lang.String typ,
+                                  java.lang.String methode,
+                                  int anzahl)
        +
        Führt einen Laufzeittest aus. Wiederholt den Test 100 mal, um Ausreißer zu vermeiden. + Sollte nicht direkt aufgerufen werden.
        +
        +
        Parameters:
        +
        typ - Die Unterklasse von Set, die getestet werden soll
        +
        methode - Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll
        +
        anzahl - Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert
        +
        Returns:
        +
        Die Laufzeit des Tests in Mikrosekunden (µs)
        +
        +
        • +
      + + + +
        +
      • +

        speicherTest

        +
        protected static int speicherTest​(java.lang.String typ,
+                                  java.lang.String methode,
+                                  int anzahl)
        +
        Führt einen Speichertest aus. Sollte nicht direkt aufgerufen werden.
        +
        +
        Parameters:
        +
        typ - Die Unterklasse von Set, die getestet werden soll
        +
        methode - Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll
        +
        anzahl - Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert
        +
        Returns:
        +
        Die Größe der Set in Bytes, nachdem die Testmethode ausgeführt wurde
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/MeinBenchmark.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/MeinBenchmark.html new file mode 100644 index 0000000..d309708 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/MeinBenchmark.html @@ -0,0 +1,230 @@ + + + + + +MeinBenchmark + + + + + + + + + +
+
+

Class MeinBenchmark

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • BenchmarkBase
      • +
    • +
        +
      • MeinBenchmark
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class MeinBenchmark
+extends BenchmarkBase
    +
    Führt Leistungstests mit verschiedenen Set-Implementationen aus
    +
    +
    Version:
    +
    November 2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Summary

      +
        +
      • + + +

        Fields inherited from class BenchmarkBase

        +theSet, zufallszahlen
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      MeinBenchmark() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      static voidlaufzeitTestAusfuehren() +
      Führt einen Laufzeittest mit 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus.
      +
      voidmeinTest​(int n) 
      static voidspeicherTestAusfuehren() +
      Führt einen Speichertest mit 100 Elementen aus und gibt das Ergebnis auf der Konsole aus.
      +
      +
        +
      • + + +

        Methods inherited from class BenchmarkBase

        +init, laufzeitTest, main, speicherTest
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MeinBenchmark

        +
        public MeinBenchmark()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        meinTest

        +
        public void meinTest​(int n)
        +
        • +
      + + + +
        +
      • +

        speicherTestAusfuehren

        +
        public static void speicherTestAusfuehren()
        +
        Führt einen Speichertest mit 100 Elementen aus und gibt das Ergebnis auf der Konsole aus.
        +
        • +
      + + + +
        +
      • +

        laufzeitTestAusfuehren

        +
        public static void laufzeitTestAusfuehren()
        +
        Führt einen Laufzeittest mit 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus.
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/Set.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/Set.html new file mode 100644 index 0000000..78c7413 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/Set.html @@ -0,0 +1,410 @@ + + + + + +Set + + + + + + + + + +
+
+

Class Set

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    +
    • +
+
+
    +
  • +
    +
    public abstract class Set
+extends java.lang.Object
    +
    Schnittstelle des ADTs Set
    +
    +
    Version:
    +
    26.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      Set() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected abstract int[]alsArray() 
      abstract intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      abstract Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      abstract voideinfuegen​(int wert) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      abstract voidentfernen​(int wert) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      abstract booleanenthaelt​(int wert) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleangleich​(Set s) +
      Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
      +
      abstract booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      abstract Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      java.lang.StringtoString() +
      Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück
      +
      abstract booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      abstract Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Set

        +
        public Set()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        einfuegen

        +
        public abstract void einfuegen​(int wert)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public abstract void entfernen​(int wert)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public abstract boolean enthaelt​(int wert)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public abstract Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public abstract Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public abstract boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public abstract Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public abstract int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        istLeer

        +
        public abstract boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        alsArray

        +
        protected abstract int[] alsArray()
        +
        • +
      + + + +
        +
      • +

        gleich

        +
        public boolean gleich​(Set s)
        +
        Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
        +
        +
        Parameters:
        +
        s - Die zu überprüfende Menge
        +
        Returns:
        +
        true, wenn beide Mengen die gleichen Elemente enthalten; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        Returns:
        +
        Ein String, der alle Elemente der Menge aufzählt.
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteA.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteA.html new file mode 100644 index 0000000..918de31 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteA.html @@ -0,0 +1,401 @@ + + + + + +SetVarianteA + + + + + + + + + +
+
+

Class SetVarianteA

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    • +
        +
      • SetVarianteA
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class SetVarianteA
+extends Set
    +
    Set-Variante A
    +
    +
    Version:
    +
    27.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      SetVarianteA() +
      Erzeugt eine neue leere Set
      +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected int[]alsArray() 
      intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      voideinfuegen​(int n) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      voidentfernen​(int n) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      booleanenthaelt​(int n) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class Set

        +gleich, toString
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SetVarianteA

        +
        public SetVarianteA()
        +
        Erzeugt eine neue leere Set
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        alsArray

        +
        protected int[] alsArray()
        +
        +
        Specified by:
        +
        alsArray in class Set
        +
        +
        • +
      + + + +
        +
      • +

        istLeer

        +
        public boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Specified by:
        +
        istLeer in class Set
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Specified by:
        +
        anzahl in class Set
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        differenz in class Set
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Specified by:
        +
        untermenge in class Set
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        vereinigungsmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        einfuegen

        +
        public void einfuegen​(int n)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Specified by:
        +
        einfuegen in class Set
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        schnittmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public boolean enthaelt​(int n)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Specified by:
        +
        enthaelt in class Set
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public void entfernen​(int n)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Specified by:
        +
        entfernen in class Set
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteB.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteB.html new file mode 100644 index 0000000..9e124f8 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteB.html @@ -0,0 +1,401 @@ + + + + + +SetVarianteB + + + + + + + + + +
+
+

Class SetVarianteB

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    • +
        +
      • SetVarianteB
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class SetVarianteB
+extends Set
    +
    Set-Variante B
    +
    +
    Version:
    +
    26.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      SetVarianteB() +
      Erzeugt eine neue leere Set
      +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected int[]alsArray() 
      intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      voideinfuegen​(int wert) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      voidentfernen​(int wert) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      booleanenthaelt​(int x) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class Set

        +gleich, toString
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SetVarianteB

        +
        public SetVarianteB()
        +
        Erzeugt eine neue leere Set
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        istLeer

        +
        public boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Specified by:
        +
        istLeer in class Set
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Specified by:
        +
        anzahl in class Set
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        differenz in class Set
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Specified by:
        +
        untermenge in class Set
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        vereinigungsmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        alsArray

        +
        protected int[] alsArray()
        +
        +
        Specified by:
        +
        alsArray in class Set
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        schnittmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public boolean enthaelt​(int x)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Specified by:
        +
        enthaelt in class Set
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public void entfernen​(int wert)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Specified by:
        +
        entfernen in class Set
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      + + + +
        +
      • +

        einfuegen

        +
        public void einfuegen​(int wert)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Specified by:
        +
        einfuegen in class Set
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteC.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteC.html new file mode 100644 index 0000000..6a86811 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/SetVarianteC.html @@ -0,0 +1,426 @@ + + + + + +SetVarianteC + + + + + + + + + +
+
+

Class SetVarianteC

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    • +
        +
      • SetVarianteC
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class SetVarianteC
+extends Set
    +
    Set-Variante C
    +
    +
    Version:
    +
    26.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      SetVarianteC() +
      Erzeugt eine neue leere Set
      +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected int[]alsArray() 
      intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      voideinfuegen​(int x) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      voidentfernen​(int x) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      booleanenthaelt​(int x) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleangleich​(Set s) +
      Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
      +
      booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class Set

        +toString
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SetVarianteC

        +
        public SetVarianteC()
        +
        Erzeugt eine neue leere Set
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        alsArray

        +
        protected int[] alsArray()
        +
        +
        Specified by:
        +
        alsArray in class Set
        +
        +
        • +
      + + + +
        +
      • +

        istLeer

        +
        public boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Specified by:
        +
        istLeer in class Set
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public boolean enthaelt​(int x)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Specified by:
        +
        enthaelt in class Set
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Specified by:
        +
        anzahl in class Set
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        differenz in class Set
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        einfuegen

        +
        public void einfuegen​(int x)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Specified by:
        +
        einfuegen in class Set
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Specified by:
        +
        untermenge in class Set
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        vereinigungsmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        schnittmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public void entfernen​(int x)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Specified by:
        +
        entfernen in class Set
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      + + + +
        +
      • +

        gleich

        +
        public boolean gleich​(Set s)
        +
        Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
        +
        +
        Overrides:
        +
        gleich in class Set
        +
        Parameters:
        +
        s - Die zu überprüfende Menge
        +
        Returns:
        +
        true, wenn beide Mengen die gleichen Elemente enthalten; false sonst
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/allclasses.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/allclasses.html new file mode 100644 index 0000000..595ef81 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/allclasses.html @@ -0,0 +1,20 @@ + + + + + +All Classes + + + + + + +

All Classes

+
+ +
+ + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/constant-values.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/constant-values.html new file mode 100644 index 0000000..1771f3f --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/constant-values.html @@ -0,0 +1,35 @@ + + + + + +Constant Field Values + + + + + + + + +
+
+

Constant Field Values

+
+

Contents

+
+
+
+ + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/element-list b/Quellcodes/Alg_DS_Set/01_set_roh/doc/element-list new file mode 100644 index 0000000..0e722c7 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/element-list @@ -0,0 +1 @@ +unnamed package diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/index.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/index.html new file mode 100644 index 0000000..cd12d84 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/index.html @@ -0,0 +1,23 @@ + + + + + +Generated Documentation (Untitled) + + + + + + + +
+ +

SetVarianteC.html

+
+ + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/logfile.txt b/Quellcodes/Alg_DS_Set/01_set_roh/doc/logfile.txt new file mode 100644 index 0000000..c13cdec --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/logfile.txt @@ -0,0 +1,40 @@ +Class documentation +<---- javadoc command: ----> +D:\Program Files\BlueJ\jdk\bin\javadoc.exe +-author +-version +-nodeprecated +-package +-Xdoclint:none +-noindex +-notree +-nohelp +-nonavbar +-source +11 +-classpath +D:\Program Files\BlueJ\lib\bluejcore.jar;D:\Program Files\BlueJ\lib\junit-4.11.jar;D:\Program Files\BlueJ\lib\hamcrest-core-1.3.jar;D:\Program Files\BlueJ\lib\lang-stride.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.base.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.controls.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.fxml.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.graphics.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.media.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.properties.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.swing.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.web.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\Weiterentwicklung der Informatik ab 2015\Eigener Ablauf\Regionaltag 9+10\Turtle - Lösung\aplu5.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\+libs\SizeOf.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode) +-d +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc +-encoding +UTF-8 +-charset +UTF-8 +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java +<---- end of javadoc command ----> +Loading source file D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java... +Constructing Javadoc information... +Standard Doclet version 11.0.2 +Building tree for all the packages and classes... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\SetVarianteC.html... +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java:54: warning - @param argument "wert" is not a parameter name. +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java:117: warning - @param argument "wert" is not a parameter name. +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java:243: warning - @param argument "wert" is not a parameter name. +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\package-summary.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\constant-values.html... +Building index for all the packages and classes... +Building index for all classes... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\allclasses.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\allclasses.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\index.html... +3 warnings diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/package-summary.html b/Quellcodes/Alg_DS_Set/01_set_roh/doc/package-summary.html new file mode 100644 index 0000000..987db39 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/package-summary.html @@ -0,0 +1,53 @@ + + + + + +<Unnamed> + + + + + + + + +
+
+

Package <Unnamed>

+
+
+
    +
  • + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    SetVarianteC +
    Set-Variante C
    +
    +
    • +
+
+
+ + diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/script.js b/Quellcodes/Alg_DS_Set/01_set_roh/doc/script.js new file mode 100644 index 0000000..d33d3ab --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/script.js @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +var moduleSearchIndex; +var packageSearchIndex; +var typeSearchIndex; +var memberSearchIndex; +var tagSearchIndex; +function loadScripts(doc, tag) { + createElem(doc, tag, 'jquery/jszip/dist/jszip.js'); + createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils.js'); + if (window.navigator.userAgent.indexOf('MSIE ') > 0 || window.navigator.userAgent.indexOf('Trident/') > 0 || + window.navigator.userAgent.indexOf('Edge/') > 0) { + createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils-ie.js'); + } + createElem(doc, tag, 'search.js'); + + $.get(pathtoroot + "module-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "module-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + moduleSearchIndex = JSON.parse(zip.file("module-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "package-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "package-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + packageSearchIndex = JSON.parse(zip.file("package-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "type-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "type-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + typeSearchIndex = JSON.parse(zip.file("type-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "member-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "member-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + memberSearchIndex = JSON.parse(zip.file("member-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "tag-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "tag-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + tagSearchIndex = JSON.parse(zip.file("tag-search-index.json").asText()); + }); + }); + if (!moduleSearchIndex) { + createElem(doc, tag, 'module-search-index.js'); + } + if (!packageSearchIndex) { + createElem(doc, tag, 'package-search-index.js'); + } + if (!typeSearchIndex) { + createElem(doc, tag, 'type-search-index.js'); + } + if (!memberSearchIndex) { + createElem(doc, tag, 'member-search-index.js'); + } + if (!tagSearchIndex) { + createElem(doc, tag, 'tag-search-index.js'); + } + $(window).resize(function() { + $('.navPadding').css('padding-top', $('.fixedNav').css("height")); + }); +} + +function createElem(doc, tag, path) { + var script = doc.createElement(tag); + var scriptElement = doc.getElementsByTagName(tag)[0]; + script.src = pathtoroot + path; + scriptElement.parentNode.insertBefore(script, scriptElement); +} + +function show(type) { + count = 0; + for (var key in data) { + var row = document.getElementById(key); + if ((data[key] & type) !== 0) { + row.style.display = ''; + row.className = (count++ % 2) ? rowColor : altColor; + } + else + row.style.display = 'none'; + } + updateTabs(type); +} + +function updateTabs(type) { + for (var value in tabs) { + var sNode = document.getElementById(tabs[value][0]); + var spanNode = sNode.firstChild; + if (value == type) { + sNode.className = activeTableTab; + spanNode.innerHTML = tabs[value][1]; + } + else { + sNode.className = tableTab; + spanNode.innerHTML = "" + tabs[value][1] + ""; + } + } +} + +function updateModuleFrame(pFrame, cFrame) { + top.packageFrame.location = pFrame; + top.classFrame.location = cFrame; +} diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/doc/stylesheet.css b/Quellcodes/Alg_DS_Set/01_set_roh/doc/stylesheet.css new file mode 100644 index 0000000..c027275 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/doc/stylesheet.css @@ -0,0 +1,906 @@ +/* + * Javadoc style sheet + */ + +@import url('resources/fonts/dejavu.css'); + +/* + * Styles for individual HTML elements. + * + * These are styles that are specific to individual HTML elements. Changing them affects the style of a particular + * HTML element throughout the page. + */ + +body { + background-color:#ffffff; + color:#353833; + font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; + font-size:14px; + margin:0; + padding:0; + height:100%; + width:100%; +} +iframe { + margin:0; + padding:0; + height:100%; + width:100%; + overflow-y:scroll; + border:none; +} +a:link, a:visited { + text-decoration:none; + color:#4A6782; +} +a[href]:hover, a[href]:focus { + text-decoration:none; + color:#bb7a2a; +} +a[name] { + color:#353833; +} +a[name]:before, a[name]:target, a[id]:before, a[id]:target { + content:""; + display:inline-block; + position:relative; + padding-top:129px; + margin-top:-129px; +} +pre { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; +} +h1 { + font-size:20px; +} +h2 { + font-size:18px; +} +h3 { + font-size:16px; + font-style:italic; +} +h4 { + font-size:13px; +} +h5 { + font-size:12px; +} +h6 { + font-size:11px; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; +} +table tr td dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} + +/* + * Styles for HTML generated by javadoc. + * + * These are style classes that are used by the standard doclet to generate HTML documentation. + */ + +/* + * Styles for document title and copyright. + */ +.clear { + clear:both; + height:0px; + overflow:hidden; +} +.aboutLanguage { + float:right; + padding:0px 21px; + font-size:11px; + z-index:200; + margin-top:-9px; +} +.legalCopy { + margin-left:.5em; +} +.bar a, .bar a:link, .bar a:visited, .bar a:active { + color:#FFFFFF; + text-decoration:none; +} +.bar a:hover, .bar a:focus { + color:#bb7a2a; +} +.tab { + background-color:#0066FF; + color:#ffffff; + padding:8px; + width:5em; + font-weight:bold; +} +/* + * Styles for navigation bar. + */ +.bar { + background-color:#4D7A97; + color:#FFFFFF; + padding:.8em .5em .4em .8em; + height:auto;/*height:1.8em;*/ + font-size:11px; + margin:0; +} +.navPadding { + padding-top: 107px; +} +.fixedNav { + position:fixed; + width:100%; + z-index:999; + background-color:#ffffff; +} +.topNav { + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.bottomNav { + margin-top:10px; + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.subNav { + background-color:#dee3e9; + float:left; + width:100%; + overflow:hidden; + font-size:12px; +} +.subNav div { + clear:left; + float:left; + padding:0 0 5px 6px; + text-transform:uppercase; +} +ul.navList, ul.subNavList { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.navList li{ + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +ul.navListSearch { + float:right; + margin:0 0 0 0; + padding:0; +} +ul.navListSearch li { + list-style:none; + float:right; + padding: 5px 6px; + text-transform:uppercase; +} +ul.navListSearch li label { + position:relative; + right:-16px; +} +ul.subNavList li { + list-style:none; + float:left; +} +.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { + color:#FFFFFF; + text-decoration:none; + text-transform:uppercase; +} +.topNav a:hover, .bottomNav a:hover { + text-decoration:none; + color:#bb7a2a; + text-transform:uppercase; +} +.navBarCell1Rev { + background-color:#F8981D; + color:#253441; + margin: auto 5px; +} +.skipNav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* + * Styles for page header and footer. + */ +.header, .footer { + clear:both; + margin:0 20px; + padding:5px 0 0 0; +} +.indexNav { + position:relative; + font-size:12px; + background-color:#dee3e9; +} +.indexNav ul { + margin-top:0; + padding:5px; +} +.indexNav ul li { + display:inline; + list-style-type:none; + padding-right:10px; + text-transform:uppercase; +} +.indexNav h1 { + font-size:13px; +} +.title { + color:#2c4557; + margin:10px 0; +} +.subTitle { + margin:5px 0 0 0; +} +.header ul { + margin:0 0 15px 0; + padding:0; +} +.footer ul { + margin:20px 0 5px 0; +} +.header ul li, .footer ul li { + list-style:none; + font-size:13px; +} +/* + * Styles for headings. + */ +div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList li.blockList h3 { + padding:0; + margin:15px 0; +} +ul.blockList li.blockList h2 { + padding:0px 0 20px 0; +} +/* + * Styles for page layout containers. + */ +.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer, +.allClassesContainer, .allPackagesContainer { + clear:both; + padding:10px 20px; + position:relative; +} +.indexContainer { + margin:10px; + position:relative; + font-size:12px; +} +.indexContainer h2 { + font-size:13px; + padding:0 0 3px 0; +} +.indexContainer ul { + margin:0; + padding:0; +} +.indexContainer ul li { + list-style:none; + padding-top:2px; +} +.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { + font-size:12px; + font-weight:bold; + margin:10px 0 0 0; + color:#4E4E4E; +} +.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { + margin:5px 0 10px 0px; + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} +.serializedFormContainer dl.nameValue dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +.serializedFormContainer dl.nameValue dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* + * Styles for lists. + */ +li.circle { + list-style:circle; +} +ul.horizontal li { + display:inline; + font-size:0.9em; +} +ul.inheritance { + margin:0; + padding:0; +} +ul.inheritance li { + display:inline; + list-style:none; +} +ul.inheritance li ul.inheritance { + margin-left:15px; + padding-left:15px; + padding-top:1px; +} +ul.blockList, ul.blockListLast { + margin:10px 0 10px 0; + padding:0; +} +ul.blockList li.blockList, ul.blockListLast li.blockList { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { + padding:0px 20px 5px 10px; + border:1px solid #ededed; + background-color:#f8f8f8; +} +ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { + padding:0 0 5px 8px; + background-color:#ffffff; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { + margin-left:0; + padding-left:0; + padding-bottom:15px; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { + list-style:none; + border-bottom:none; + padding-bottom:0; +} +table tr td dl, table tr td dl dt, table tr td dl dd { + margin-top:0; + margin-bottom:1px; +} +/* + * Styles for tables. + */ +.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary, +.requiresSummary, .packagesSummary, .providesSummary, .usesSummary { + width:100%; + border-spacing:0; + border-left:1px solid #EEE; + border-right:1px solid #EEE; + border-bottom:1px solid #EEE; +} +.overviewSummary, .memberSummary, .requiresSummary, .packagesSummary, .providesSummary, .usesSummary { + padding:0px; +} +.overviewSummary caption, .memberSummary caption, .typeSummary caption, +.useSummary caption, .constantsSummary caption, .deprecatedSummary caption, +.requiresSummary caption, .packagesSummary caption, .providesSummary caption, .usesSummary caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:#253441; + font-weight:bold; + clear:none; + overflow:hidden; + padding:0px; + padding-top:10px; + padding-left:1px; + margin:0px; + white-space:pre; +} +.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, +.constantsSummary caption a:link, .deprecatedSummary caption a:link, +.requiresSummary caption a:link, .packagesSummary caption a:link, .providesSummary caption a:link, +.usesSummary caption a:link, +.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, +.constantsSummary caption a:hover, .deprecatedSummary caption a:hover, +.requiresSummary caption a:hover, .packagesSummary caption a:hover, .providesSummary caption a:hover, +.usesSummary caption a:hover, +.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, +.constantsSummary caption a:active, .deprecatedSummary caption a:active, +.requiresSummary caption a:active, .packagesSummary caption a:active, .providesSummary caption a:active, +.usesSummary caption a:active, +.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, +.constantsSummary caption a:visited, .deprecatedSummary caption a:visited, +.requiresSummary caption a:visited, .packagesSummary caption a:visited, .providesSummary caption a:visited, +.usesSummary caption a:visited { + color:#FFFFFF; +} +.useSummary caption a:link, .useSummary caption a:hover, .useSummary caption a:active, +.useSummary caption a:visited { + color:#1f389c; +} +.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, +.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span, +.requiresSummary caption span, .packagesSummary caption span, .providesSummary caption span, +.usesSummary caption span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + padding-bottom:7px; + display:inline-block; + float:left; + background-color:#F8981D; + border: none; + height:16px; +} +.memberSummary caption span.activeTableTab span, .packagesSummary caption span.activeTableTab span, +.overviewSummary caption span.activeTableTab span, .typeSummary caption span.activeTableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#F8981D; + height:16px; +} +.memberSummary caption span.tableTab span, .packagesSummary caption span.tableTab span, +.overviewSummary caption span.tableTab span, .typeSummary caption span.tableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#4D7A97; + height:16px; +} +.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab, +.packagesSummary caption span.tableTab, .packagesSummary caption span.activeTableTab, +.overviewSummary caption span.tableTab, .overviewSummary caption span.activeTableTab, +.typeSummary caption span.tableTab, .typeSummary caption span.activeTableTab { + padding-top:0px; + padding-left:0px; + padding-right:0px; + background-image:none; + float:none; + display:inline; +} +.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, +.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd, +.requiresSummary .tabEnd, .packagesSummary .tabEnd, .providesSummary .tabEnd, .usesSummary .tabEnd { + display:none; + width:5px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .activeTableTab .tabEnd, .packagesSummary .activeTableTab .tabEnd, +.overviewSummary .activeTableTab .tabEnd, .typeSummary .activeTableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .tableTab .tabEnd, .packagesSummary .tableTab .tabEnd, +.overviewSummary .tableTab .tabEnd, .typeSummary .tableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + background-color:#4D7A97; + float:left; +} +.rowColor th, .altColor th { + font-weight:normal; +} +.overviewSummary td, .memberSummary td, .typeSummary td, +.useSummary td, .constantsSummary td, .deprecatedSummary td, +.requiresSummary td, .packagesSummary td, .providesSummary td, .usesSummary td { + text-align:left; + padding:0px 0px 12px 10px; +} +th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .useSummary th, +.constantsSummary th, .packagesSummary th, td.colFirst, td.colSecond, td.colLast, .useSummary td, +.constantsSummary td { + vertical-align:top; + padding-right:0px; + padding-top:8px; + padding-bottom:3px; +} +th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .constantsSummary th, +.packagesSummary th { + background:#dee3e9; + text-align:left; + padding:8px 3px 3px 7px; +} +td.colFirst, th.colFirst { + font-size:13px; +} +td.colSecond, th.colSecond, td.colLast, th.colConstructorName, th.colDeprecatedItemName, th.colLast { + font-size:13px; +} +.constantsSummary th, .packagesSummary th { + font-size:13px; +} +.providesSummary th.colFirst, .providesSummary th.colLast, .providesSummary td.colFirst, +.providesSummary td.colLast { + white-space:normal; + font-size:13px; +} +.overviewSummary td.colFirst, .overviewSummary th.colFirst, +.requiresSummary td.colFirst, .requiresSummary th.colFirst, +.packagesSummary td.colFirst, .packagesSummary td.colSecond, .packagesSummary th.colFirst, .packagesSummary th, +.usesSummary td.colFirst, .usesSummary th.colFirst, +.providesSummary td.colFirst, .providesSummary th.colFirst, +.memberSummary td.colFirst, .memberSummary th.colFirst, +.memberSummary td.colSecond, .memberSummary th.colSecond, .memberSummary th.colConstructorName, +.typeSummary td.colFirst, .typeSummary th.colFirst { + vertical-align:top; +} +.packagesSummary th.colLast, .packagesSummary td.colLast { + white-space:normal; +} +td.colFirst a:link, td.colFirst a:visited, +td.colSecond a:link, td.colSecond a:visited, +th.colFirst a:link, th.colFirst a:visited, +th.colSecond a:link, th.colSecond a:visited, +th.colConstructorName a:link, th.colConstructorName a:visited, +th.colDeprecatedItemName a:link, th.colDeprecatedItemName a:visited, +.constantValuesContainer td a:link, .constantValuesContainer td a:visited, +.allClassesContainer td a:link, .allClassesContainer td a:visited, +.allPackagesContainer td a:link, .allPackagesContainer td a:visited { + font-weight:bold; +} +.tableSubHeadingColor { + background-color:#EEEEFF; +} +.altColor, .altColor th { + background-color:#FFFFFF; +} +.rowColor, .rowColor th { + background-color:#EEEEEF; +} +/* + * Styles for contents. + */ +.description pre { + margin-top:0; +} +.deprecatedContent { + margin:0; + padding:10px 0; +} +.docSummary { + padding:0; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + font-style:normal; +} +div.block { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} +td.colLast div { + padding-top:0px; +} +td.colLast a { + padding-bottom:3px; +} +/* + * Styles for formatting effect. + */ +.sourceLineNo { + color:green; + padding:0 30px 0 0; +} +h1.hidden { + visibility:hidden; + overflow:hidden; + font-size:10px; +} +.block { + display:block; + margin:3px 10px 2px 0px; + color:#474747; +} +.deprecatedLabel, .descfrmTypeLabel, .implementationLabel, .memberNameLabel, .memberNameLink, +.moduleLabelInPackage, .moduleLabelInType, .overrideSpecifyLabel, .packageLabelInType, +.packageHierarchyLabel, .paramLabel, .returnLabel, .seeLabel, .simpleTagLabel, +.throwsLabel, .typeNameLabel, .typeNameLink, .searchTagLink { + font-weight:bold; +} +.deprecationComment, .emphasizedPhrase, .interfaceName { + font-style:italic; +} +.deprecationBlock { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; + border-style:solid; + border-width:thin; + border-radius:10px; + padding:10px; + margin-bottom:10px; + margin-right:10px; + display:inline-block; +} +div.block div.deprecationComment, div.block div.block span.emphasizedPhrase, +div.block div.block span.interfaceName { + font-style:normal; +} +div.contentContainer ul.blockList li.blockList h2 { + padding-bottom:0px; +} +/* + * Styles for IFRAME. + */ +.mainContainer { + margin:0 auto; + padding:0; + height:100%; + width:100%; + position:fixed; + top:0; + left:0; +} +.leftContainer { + height:100%; + position:fixed; + width:320px; +} +.leftTop { + position:relative; + float:left; + width:315px; + top:0; + left:0; + height:30%; + border-right:6px solid #ccc; + border-bottom:6px solid #ccc; +} +.leftBottom { + position:relative; + float:left; + width:315px; + bottom:0; + left:0; + height:70%; + border-right:6px solid #ccc; + border-top:1px solid #000; +} +.rightContainer { + position:absolute; + left:320px; + top:0; + bottom:0; + height:100%; + right:0; + border-left:1px solid #000; +} +.rightIframe { + margin:0; + padding:0; + height:100%; + right:30px; + width:100%; + overflow:visible; + margin-bottom:30px; +} +/* + * Styles specific to HTML5 elements. + */ +main, nav, header, footer, section { + display:block; +} +/* + * Styles for javadoc search. + */ +.ui-autocomplete-category { + font-weight:bold; + font-size:15px; + padding:7px 0 7px 3px; + background-color:#4D7A97; + color:#FFFFFF; +} +.resultItem { + font-size:13px; +} +.ui-autocomplete { + max-height:85%; + max-width:65%; + overflow-y:scroll; + overflow-x:scroll; + white-space:nowrap; + box-shadow: 0 3px 6px rgba(0,0,0,0.16), 0 3px 6px rgba(0,0,0,0.23); +} +ul.ui-autocomplete { + position:fixed; + z-index:999999; +} +ul.ui-autocomplete li { + float:left; + clear:both; + width:100%; +} +.resultHighlight { + font-weight:bold; +} +#search { + background-image:url('resources/glass.png'); + background-size:13px; + background-repeat:no-repeat; + background-position:2px 3px; + padding-left:20px; + position:relative; + right:-18px; +} +#reset { + background-color: rgb(255,255,255); + background-image:url('resources/x.png'); + background-position:center; + background-repeat:no-repeat; + background-size:12px; + border:0 none; + width:16px; + height:17px; + position:relative; + left:-4px; + top:-4px; + font-size:0px; +} +.watermark { + color:#545454; +} +.searchTagDescResult { + font-style:italic; + font-size:11px; +} +.searchTagHolderResult { + font-style:italic; + font-size:12px; +} +.searchTagResult:before, .searchTagResult:target { + color:red; +} +.moduleGraph span { + display:none; + position:absolute; +} +.moduleGraph:hover span { + display:block; + margin: -100px 0 0 100px; + z-index: 1; +} +.methodSignature { + white-space:normal; +} + +/* + * Styles for user-provided tables. + * + * borderless: + * No borders, vertical margins, styled caption. + * This style is provided for use with existing doc comments. + * In general, borderless tables should not be used for layout purposes. + * + * plain: + * Plain borders around table and cells, vertical margins, styled caption. + * Best for small tables or for complex tables for tables with cells that span + * rows and columns, when the "striped" style does not work well. + * + * striped: + * Borders around the table and vertical borders between cells, striped rows, + * vertical margins, styled caption. + * Best for tables that have a header row, and a body containing a series of simple rows. + */ + +table.borderless, +table.plain, +table.striped { + margin-top: 10px; + margin-bottom: 10px; +} +table.borderless > caption, +table.plain > caption, +table.striped > caption { + font-weight: bold; + font-size: smaller; +} +table.borderless th, table.borderless td, +table.plain th, table.plain td, +table.striped th, table.striped td { + padding: 2px 5px; +} +table.borderless, +table.borderless > thead > tr > th, table.borderless > tbody > tr > th, table.borderless > tr > th, +table.borderless > thead > tr > td, table.borderless > tbody > tr > td, table.borderless > tr > td { + border: none; +} +table.borderless > thead > tr, table.borderless > tbody > tr, table.borderless > tr { + background-color: transparent; +} +table.plain { + border-collapse: collapse; + border: 1px solid black; +} +table.plain > thead > tr, table.plain > tbody tr, table.plain > tr { + background-color: transparent; +} +table.plain > thead > tr > th, table.plain > tbody > tr > th, table.plain > tr > th, +table.plain > thead > tr > td, table.plain > tbody > tr > td, table.plain > tr > td { + border: 1px solid black; +} +table.striped { + border-collapse: collapse; + border: 1px solid black; +} +table.striped > thead { + background-color: #E3E3E3; +} +table.striped > thead > tr > th, table.striped > thead > tr > td { + border: 1px solid black; +} +table.striped > tbody > tr:nth-child(even) { + background-color: #EEE +} +table.striped > tbody > tr:nth-child(odd) { + background-color: #FFF +} +table.striped > tbody > tr > th, table.striped > tbody > tr > td { + border-left: 1px solid black; + border-right: 1px solid black; +} +table.striped > tbody > tr > th { + font-weight: normal; +} diff --git a/Quellcodes/Alg_DS_Set/01_set_roh/package.bluej b/Quellcodes/Alg_DS_Set/01_set_roh/package.bluej new file mode 100644 index 0000000..d6e60d1 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/01_set_roh/package.bluej @@ -0,0 +1,73 @@ +#BlueJ package file +dependency1.from=BenchmarkBase +dependency1.to=Set +dependency1.type=UsesDependency +dependency2.from=BenchmarkBase +dependency2.to=MeinBenchmark +dependency2.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1109 +editor.fx.0.x=552 +editor.fx.0.y=100 +objectbench.height=128 +objectbench.width=996 +package.divider.horizontal=0.654 +package.divider.vertical=0.7867298578199052 +package.editor.height=491 +package.editor.width=885 +package.editor.x=469 +package.editor.y=133 +package.frame.height=733 +package.frame.width=1036 +package.numDependencies=2 +package.numTargets=6 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=BenchmarkBase +target1.showInterface=false +target1.type=ClassTarget +target1.width=120 +target1.x=60 +target1.y=200 +target2.height=50 +target2.name=MeinBenchmark +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=150 +target2.y=300 +target3.height=50 +target3.name=Set +target3.showInterface=false +target3.type=AbstractTarget +target3.width=80 +target3.x=320 +target3.y=20 +target4.height=50 +target4.name=SetVarianteC +target4.showInterface=false +target4.type=ClassTarget +target4.width=110 +target4.x=440 +target4.y=190 +target5.height=50 +target5.name=SetVarianteB +target5.showInterface=false +target5.type=ClassTarget +target5.width=110 +target5.x=320 +target5.y=190 +target6.height=50 +target6.name=SetVarianteA +target6.showInterface=false +target6.type=ClassTarget +target6.width=110 +target6.x=200 +target6.y=190 diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/+libs/SizeOf.jar b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/+libs/SizeOf.jar new file mode 100644 index 0000000..d1cc0f5 Binary files /dev/null and b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/+libs/SizeOf.jar differ diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/+libs/license.txt b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/+libs/license.txt new file mode 100644 index 0000000..eeb85a6 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/+libs/license.txt @@ -0,0 +1,3 @@ +Quelle: https://github.com/afeinberg/sizeof +GNU Public License 2.0 +Modifikationen von Rainer Helfrich \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/BenchmarkBase.java b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/BenchmarkBase.java new file mode 100644 index 0000000..fde5186 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/BenchmarkBase.java @@ -0,0 +1,124 @@ +import java.util.*; +import net.sourceforge.sizeof.*; +import java.io.*; +import java.lang.reflect.*; + +/** + * Testet Set-Varianten auf ihre Effizenz + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class BenchmarkBase +{ + protected Set theSet; + Random zufallszahlen; + + protected BenchmarkBase() + { + zufallszahlen = new Random(); + } + + protected void init(Class c) throws Exception + { + theSet = (Set)c.newInstance(); + } + + /** + * Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + * Sollte nicht direkt aufgerufen werden. + */ + public static void main(String[] args) + { + try + { + int anzahl = Integer.parseInt(args[0]); + Class c = Class.forName(args[1]); + MeinBenchmark b = new MeinBenchmark(); + b.init(c); + Method m = b.getClass().getMethod(args[2], new Class[]{int.class}); + m.invoke(b, new Object[]{anzahl}); + System.out.println("@"+SizeOf.deepSizeOf((Object)b.theSet)+"@"); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + } + + /** + * Führt einen Laufzeittest aus. Wiederholt den Test 100 mal, um Ausreißer zu vermeiden. + * Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Laufzeit des Tests in Mikrosekunden (µs) + */ + protected static int laufzeitTest(String typ, String methode, int anzahl) + { + try + { + Class c = Class.forName(typ); + MeinBenchmark b = new MeinBenchmark(); + final int DURCHGAENGE = 100; + long totalTime = 0; + for (int i = 0; i < DURCHGAENGE; i++) + { + b.init(c); + Method m = b.getClass().getMethod(methode, new Class[]{int.class}); + long vorher = System.nanoTime(); + m.invoke(b, new Object[]{anzahl}); + long nachher = System.nanoTime(); + totalTime += (nachher - vorher) / 1000; + } + return (int)(totalTime / DURCHGAENGE); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } + + /** + * Führt einen Speichertest aus. Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Größe der Set in Bytes, nachdem die Testmethode ausgeführt wurde + */ + protected static int speicherTest(String typ, String methode, int anzahl) + { + try + { + Process process = new ProcessBuilder("java","-javaagent:./+libs/SizeOf.jar", MeinBenchmark.class.getName(), ""+anzahl, typ, methode).start(); + InputStream is = process.getInputStream(); + InputStreamReader isr = new InputStreamReader(is); + BufferedReader br = new BufferedReader(isr); + String line; + + StringBuilder sb = new StringBuilder(); + while ((line = br.readLine()) != null) { + sb.append(line); + } + String strOut = sb.toString(); + int idx = strOut.indexOf("@"); + if (idx < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int idx2 = strOut.indexOf("@", idx+1); + if (idx2 < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int n = Integer.parseInt(strOut.substring(idx+1, idx2)); + return n; + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/MeinBenchmark.java b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/MeinBenchmark.java new file mode 100644 index 0000000..14f8e8b --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/MeinBenchmark.java @@ -0,0 +1,60 @@ + +/** + * Führt Leistungstests mit verschiedenen Set-Implementationen aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class MeinBenchmark extends BenchmarkBase +{ + + //# Die Klassen SetVarianteA, SetVarianteB und SetVarianteC sind drei verschiedene Implementationen + //# des ADTs Set: Mit ArrayList, mit Bitvektor und als Hashtable. + //# Sie verhalten sich logisch gleich, zeigen aber verschiedene Eigenschaften in Bezug auf + //# Laufzeit und Speicherbedarf (vgl. Unterricht). + //# Konstruieren Sie Testfälle, mit denen man den Unterschied der Implementationsvarianten + //# erkennen kann. + //# Rufen Sie die Methoden speicherTestAusfuehren bzw. laufzeitTestAusfuehren auf, + //# um die Messergebnisse zu sehen. + + public void meinTest(int anzahl) + { + //# TODO: Konstruieren Sie einen Testfall, um herauszufinden, welche Implementation verwendet wird. + //# Der Parameter anzahl entspricht der Variablen anzahl in der Methode speicherTestAusfuehren bzw. laufzeitTestAusfuehren + //# Sie können die Methoden des Objekts theSet (ein Set-Objekt) verwenden. + for (int i = 0; i < anzahl; i++) + { + theSet.einfuegen(i); + } + } + + /** + * Führt einen Speichertest mit z.B. 100 Elementen aus und gibt das Ergebnis auf der Konsole aus. + */ + public static void speicherTestAusfuehren() + { + int anzahl = 100; + String methodenName = "meinTest"; + // Die Variable methodenName muss einer statischen Methode in dieser Klasse entsprechen + int sizeA = speicherTest("SetVarianteA", methodenName, anzahl); + int sizeB = speicherTest("SetVarianteB", methodenName, anzahl); + int sizeC = speicherTest("SetVarianteC", methodenName, anzahl); + System.out.println(String.format("%d Zahlen; SetVarianteA: %d Bytes; SetVarianteB: %d Bytes; SetVarianteC: %d Bytes", + anzahl, sizeA, sizeB, sizeC)); + } + + /** + * Führt einen Laufzeittest mit z.B. 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus. + */ + public static void laufzeitTestAusfuehren() + { + int anzahl = 1000; + String methodenName = "meinTest"; + // Die Variable methodenName muss einer statischen Methode in dieser Klasse entsprechen + long timeA = laufzeitTest("SetVarianteA", methodenName, anzahl); + long timeB = laufzeitTest("SetVarianteB", methodenName, anzahl); + long timeC = laufzeitTest("SetVarianteC", methodenName, anzahl); + System.out.println(String.format("%d Zahlen; SetVarianteA: %d µs; SetVarianteB: %d µs; SetVarianteC: %d µs", + anzahl, timeA, timeB, timeC)); + } +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/README.TXT b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/README.TXT new file mode 100644 index 0000000..fb73768 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Set-Benchmark +PROJEKTZWECK: Konstruieren Sie einen Benchmark, um herauszufinden, um welche Implementation es sich bei einer Set handelt. +VERSION oder DATUM: November 2020 +WIE IST DAS PROJEKT ZU STARTEN: Nachdem Sie in der Methode meinTest der Klasse MeinBenchmark einen Test definiert haben, rufen Sie eine der statischen Methoden speicherTestAusfuehren() oder laufzeitTestAusfuehren() auf. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/Set.java b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/Set.java new file mode 100644 index 0000000..753b99d --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/Set.java @@ -0,0 +1,107 @@ +/** + * Schnittstelle des ADTs Set + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ + +public abstract class Set +{ + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public abstract void einfuegen(int wert); + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public abstract void entfernen(int wert); + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public abstract boolean enthaelt(int wert); + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public abstract Set schnittmenge(Set s); + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public abstract Set vereinigungsmenge(Set s); + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public abstract boolean untermenge(Set s); + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public abstract Set differenz(Set s); + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public abstract int anzahl(); + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public abstract boolean istLeer(); + + protected abstract int[] alsArray(); + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + return untermenge(s) && s.untermenge(this); + } + + /** + * Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück + * @return Ein String, der alle Elemente der Menge aufzählt. + */ + @Override + public String toString() + { + if (istLeer()) + { + return "{ }"; + } + StringBuilder sb = new StringBuilder(); + for(int v : alsArray()) + { + if (sb.length() == 0) + { + sb.append("{ "); + } + else + { + sb.append(", "); + } + sb.append(v); + } + sb.append(" }"); + return sb.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteA.java b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteA.java new file mode 100644 index 0000000..677e24e --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteA.java @@ -0,0 +1,240 @@ +import java.util.ArrayList; + +/** + * Set-Variante A + * + * @author Rainer Helfrich + * @version 27.9.2020 + */ +public class SetVarianteA extends Set +{ + private ArrayList[] daten; + private int anzahl; + + /** + * Erzeugt ein neues leeres Set + */ + public SetVarianteA() + { + this(10); + } + + private SetVarianteA(int capacity) + { + if (capacity < 10) + { + capacity = 10; + } + daten = new ArrayList[capacity*2]; + anzahl = 0; + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl]; + int index = 0; + for (ArrayList l : daten) + { + if (l != null) + { + for (int x : l) + { + ergebnis[index] = x; + index++; + } + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + for (ArrayList l : daten) + { + if (l != null && !l.isEmpty()) + { + return false; + } + } + return true; + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + return anzahl; + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + Set ergebnis = new SetVarianteA(anzahl); + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + if (!s.enthaelt(n)) + { + ergebnis.einfuegen(n); + } + } + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + if (!s.enthaelt(n)) + { + return false; + } + } + } + } + return true; + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + SetVarianteA ergebnis = new SetVarianteA(s.anzahl() + anzahl()); + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + ergebnis.einfuegen(n); + } + } + } + for (int n : s.alsArray()) + { + ergebnis.einfuegen(n); + } + return ergebnis; + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int n) + { + if ((double)anzahl / daten.length > 0.5) + { + rehash(); + } + int hash = n % daten.length; + if (daten[hash] == null) + { + daten[hash] = new ArrayList(2); + } + if (!daten[hash].contains(n)) + { + anzahl++; + daten[hash].add(n); + } + } + + private void rehash() + { + ArrayList[] tmp = new ArrayList[2*daten.length+1]; + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + int hash = n % tmp.length; + if (tmp[hash] == null) + { + tmp[hash] = new ArrayList(2); + } + tmp[hash].add(n); + } + } + } + daten = tmp; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + SetVarianteA ergebnis = new SetVarianteA(anzahl); + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + if (s.enthaelt(n)) + { + ergebnis.einfuegen(n); + } + } + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int n) + { + int hash = n % daten.length; + return daten[hash] != null && daten[hash].contains(n); + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int n) + { + int hash = n % daten.length; + if (daten[hash] != null) + { + if (daten[hash].contains(n)) + { + anzahl--; + daten[hash].remove(new Integer(n)); + } + } + } +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteB.java b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteB.java new file mode 100644 index 0000000..d36bcc9 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteB.java @@ -0,0 +1,151 @@ +import java.util.ArrayList; + +/** + * Set-Variante B + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ +public class SetVarianteB extends Set +{ + private ArrayList daten; + + /** + * Erzeugt ein neues leeres Set + */ + public SetVarianteB() + { + daten = new ArrayList(); + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + return daten.isEmpty(); + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + return daten.size(); + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + Set ergebnis = new SetVarianteB(); + for(int v : daten) + { + if (!s.enthaelt(v)) + { + ergebnis.einfuegen(v); + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + for (int v : daten) + { + if (!s.enthaelt(v)) + { + return false; + } + } + return true; + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + Set ergebnis = new SetVarianteB(); + for (int v : daten) + { + ergebnis.einfuegen(v); + } + for (int v : s.alsArray()) + { + ergebnis.einfuegen(v); + } + return ergebnis; + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl()]; + for (int i = 0; i < anzahl(); i++) + { + ergebnis[i] = daten.get(i); + } + return ergebnis; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + Set ergebnis = new SetVarianteB(); + for (int v : daten) + { + if (s.enthaelt(v)) + { + ergebnis.einfuegen(v); + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int x) + { + return daten.contains(x); + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int wert) + { + daten.remove(new Integer(wert)); + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int wert) + { + if (!daten.contains(wert)) + { + daten.add(wert); + } + } + +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteC.java b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteC.java new file mode 100644 index 0000000..f64179c --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/SetVarianteC.java @@ -0,0 +1,294 @@ +import java.util.ArrayList; + +/** + * Set-Variante C + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ +public class SetVarianteC extends Set +{ + private ArrayList daten; + + /** + * Erzeugt ein neues leeres Set + */ + public SetVarianteC() + { + daten = new ArrayList(); + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl()]; + int index = 0; + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i)) + { + ergebnis[index] = i; + index++; + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + for (int v : daten) + { + if (v != 0) + { + return false; + } + } + return true; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int x) + { + if (x >= 32*daten.size() || x < 0) + { + return false; + } + int i = x / 32; + int j = x % 32; + int mask = 1 << j; + return (daten.get(i) & mask) != 0; + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + int laenge = 0; + for (int i : daten) + { + laenge += Integer.bitCount(i); + } + return laenge; + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + SetVarianteC ergebnis = new SetVarianteC(); + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & ~(bs.daten.get(i))); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int x) + { + if (x >= 0) + { + int i = x / 32; + daten.ensureCapacity(i+1); + while(i >= daten.size()) + { + daten.add(0); + } + int j = x % 32; + int mask = 1 << j; + daten.set(i, daten.get(i) | mask); + } + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + int a = daten.get(i); + int b = bs.daten.get(i); + if ((a & ~b) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + return false; + } + } + return true; + } + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + SetVarianteC ergebnis = new SetVarianteC(); + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) | bs.daten.get(i)); + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + ergebnis.daten.add(bs.daten.get(i)); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + int[] a = s.alsArray(); + ergebnis.daten.addAll(daten); + for (int n : a) + { + ergebnis.einfuegen(n); + } + } + return ergebnis; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + SetVarianteC ergebnis = new SetVarianteC(); + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & bs.daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int x) + { + if (x < 32*daten.size() && x >= 0) + { + int i = x / 32; + int j = x % 32; + int mask = ~(1 << j); + daten.set(i, daten.get(i) & mask); + } + } + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + if (daten.get(i) != bs.daten.get(i)) + { + return false; + } + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + if (bs.daten.get(i) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + return super.gleich(s); + } + } +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/BenchmarkBase.html b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/BenchmarkBase.html new file mode 100644 index 0000000..80b6dc6 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/BenchmarkBase.html @@ -0,0 +1,307 @@ + + + + + +BenchmarkBase + + + + + + + + + +
+
+

Class BenchmarkBase

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • BenchmarkBase
      • +
    +
    • +
+
+
    +
  • +
    +
    public class BenchmarkBase
+extends java.lang.Object
    +
    Testet Set-Varianten auf ihre Effizenz
    +
    +
    Version:
    +
    November 2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Summary

      + + + + + + + + + + + + + + + + + +
      Fields 
      Modifier and TypeFieldDescription
      protected SettheSet 
      (package private) java.util.Randomzufallszahlen 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + + +
      Constructors 
      ModifierConstructorDescription
      protected BenchmarkBase() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected voidinit​(java.lang.Class c) 
      protected static intlaufzeitTest​(java.lang.String typ, + java.lang.String methode, + int anzahl) +
      Führt einen Laufzeittest aus.
      +
      static voidmain​(java.lang.String[] args) +
      Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen.
      +
      protected static intspeicherTest​(java.lang.String typ, + java.lang.String methode, + int anzahl) +
      Führt einen Speichertest aus.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        theSet

        +
        protected Set theSet
        +
        • +
      + + + +
        +
      • +

        zufallszahlen

        +
        java.util.Random zufallszahlen
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BenchmarkBase

        +
        protected BenchmarkBase()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        init

        +
        protected void init​(java.lang.Class c)
+             throws java.lang.Exception
        +
        +
        Throws:
        +
        java.lang.Exception
        +
        +
        • +
      + + + +
        +
      • +

        main

        +
        public static void main​(java.lang.String[] args)
        +
        Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + Sollte nicht direkt aufgerufen werden.
        +
        • +
      + + + +
        +
      • +

        laufzeitTest

        +
        protected static int laufzeitTest​(java.lang.String typ,
+                                  java.lang.String methode,
+                                  int anzahl)
        +
        Führt einen Laufzeittest aus. Wiederholt den Test 100 mal, um Ausreißer zu vermeiden. + Sollte nicht direkt aufgerufen werden.
        +
        +
        Parameters:
        +
        typ - Die Unterklasse von Set, die getestet werden soll
        +
        methode - Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll
        +
        anzahl - Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert
        +
        Returns:
        +
        Die Laufzeit des Tests in Mikrosekunden (µs)
        +
        +
        • +
      + + + +
        +
      • +

        speicherTest

        +
        protected static int speicherTest​(java.lang.String typ,
+                                  java.lang.String methode,
+                                  int anzahl)
        +
        Führt einen Speichertest aus. Sollte nicht direkt aufgerufen werden.
        +
        +
        Parameters:
        +
        typ - Die Unterklasse von Set, die getestet werden soll
        +
        methode - Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll
        +
        anzahl - Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert
        +
        Returns:
        +
        Die Größe der Set in Bytes, nachdem die Testmethode ausgeführt wurde
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/MeinBenchmark.html b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/MeinBenchmark.html new file mode 100644 index 0000000..53c72a9 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/MeinBenchmark.html @@ -0,0 +1,230 @@ + + + + + +MeinBenchmark + + + + + + + + + +
+
+

Class MeinBenchmark

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • BenchmarkBase
      • +
    • +
        +
      • MeinBenchmark
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class MeinBenchmark
+extends BenchmarkBase
    +
    Führt Leistungstests mit verschiedenen Set-Implementationen aus
    +
    +
    Version:
    +
    November 2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Summary

      +
        +
      • + + +

        Fields inherited from class BenchmarkBase

        +theSet, zufallszahlen
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      MeinBenchmark() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      static voidlaufzeitTestAusfuehren() +
      Führt einen Laufzeittest mit z.B. 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus.
      +
      voidmeinTest​(int anzahl) 
      static voidspeicherTestAusfuehren() +
      Führt einen Speichertest mit z.B. 100 Elementen aus und gibt das Ergebnis auf der Konsole aus.
      +
      +
        +
      • + + +

        Methods inherited from class BenchmarkBase

        +init, laufzeitTest, main, speicherTest
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MeinBenchmark

        +
        public MeinBenchmark()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        meinTest

        +
        public void meinTest​(int anzahl)
        +
        • +
      + + + +
        +
      • +

        speicherTestAusfuehren

        +
        public static void speicherTestAusfuehren()
        +
        Führt einen Speichertest mit z.B. 100 Elementen aus und gibt das Ergebnis auf der Konsole aus.
        +
        • +
      + + + +
        +
      • +

        laufzeitTestAusfuehren

        +
        public static void laufzeitTestAusfuehren()
        +
        Führt einen Laufzeittest mit z.B. 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus.
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/allclasses.html b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/allclasses.html new file mode 100644 index 0000000..c25b275 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/allclasses.html @@ -0,0 +1,20 @@ + + + + + +All Classes + + + + + + +

All Classes

+
+ +
+ + diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/constant-values.html b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/constant-values.html new file mode 100644 index 0000000..611f05a --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/constant-values.html @@ -0,0 +1,35 @@ + + + + + +Constant Field Values + + + + + + + + +
+
+

Constant Field Values

+
+

Contents

+
+
+
+ + diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/element-list b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/element-list new file mode 100644 index 0000000..0e722c7 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/element-list @@ -0,0 +1 @@ +unnamed package diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/index.html b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/index.html new file mode 100644 index 0000000..74e3dca --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/index.html @@ -0,0 +1,23 @@ + + + + + +Generated Documentation (Untitled) + + + + + + + +
+ +

BenchmarkBase.html

+
+ + diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/logfile.txt b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/logfile.txt new file mode 100644 index 0000000..7820a7a --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/logfile.txt @@ -0,0 +1,36 @@ +Class documentation +<---- javadoc command: ----> +D:\Program Files\BlueJ\jdk\bin\javadoc.exe +-author +-version +-nodeprecated +-package +-Xdoclint:none +-noindex +-notree +-nohelp +-nonavbar +-source +11 +-classpath +D:\Program Files\BlueJ\lib\bluejcore.jar;D:\Program Files\BlueJ\lib\junit-4.11.jar;D:\Program Files\BlueJ\lib\hamcrest-core-1.3.jar;D:\Program Files\BlueJ\lib\lang-stride.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.base.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.controls.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.fxml.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.graphics.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.media.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.properties.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.swing.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.web.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\Weiterentwicklung der Informatik ab 2015\Eigener Ablauf\Regionaltag 9+10\Turtle - Lösung\aplu5.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\+libs\SizeOf.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode) +-d +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc +-encoding +UTF-8 +-charset +UTF-8 +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\BenchmarkBase.java +<---- end of javadoc command ----> +Loading source file D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\BenchmarkBase.java... +Constructing Javadoc information... +Standard Doclet version 11.0.2 +Building tree for all the packages and classes... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\BenchmarkBase.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\package-summary.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\constant-values.html... +Building index for all the packages and classes... +Building index for all classes... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\allclasses.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\allclasses.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\index.html... diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/package-summary.html b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/package-summary.html new file mode 100644 index 0000000..6c412e9 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/package-summary.html @@ -0,0 +1,53 @@ + + + + + +<Unnamed> + + + + + + + + +
+
+

Package <Unnamed>

+
+
+
    +
  • + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    BenchmarkBase +
    Testet Set-Varianten auf ihre Effizenz
    +
    +
    • +
+
+
+ + diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/script.js b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/script.js new file mode 100644 index 0000000..d33d3ab --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/script.js @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +var moduleSearchIndex; +var packageSearchIndex; +var typeSearchIndex; +var memberSearchIndex; +var tagSearchIndex; +function loadScripts(doc, tag) { + createElem(doc, tag, 'jquery/jszip/dist/jszip.js'); + createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils.js'); + if (window.navigator.userAgent.indexOf('MSIE ') > 0 || window.navigator.userAgent.indexOf('Trident/') > 0 || + window.navigator.userAgent.indexOf('Edge/') > 0) { + createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils-ie.js'); + } + createElem(doc, tag, 'search.js'); + + $.get(pathtoroot + "module-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "module-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + moduleSearchIndex = JSON.parse(zip.file("module-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "package-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "package-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + packageSearchIndex = JSON.parse(zip.file("package-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "type-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "type-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + typeSearchIndex = JSON.parse(zip.file("type-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "member-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "member-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + memberSearchIndex = JSON.parse(zip.file("member-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "tag-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "tag-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + tagSearchIndex = JSON.parse(zip.file("tag-search-index.json").asText()); + }); + }); + if (!moduleSearchIndex) { + createElem(doc, tag, 'module-search-index.js'); + } + if (!packageSearchIndex) { + createElem(doc, tag, 'package-search-index.js'); + } + if (!typeSearchIndex) { + createElem(doc, tag, 'type-search-index.js'); + } + if (!memberSearchIndex) { + createElem(doc, tag, 'member-search-index.js'); + } + if (!tagSearchIndex) { + createElem(doc, tag, 'tag-search-index.js'); + } + $(window).resize(function() { + $('.navPadding').css('padding-top', $('.fixedNav').css("height")); + }); +} + +function createElem(doc, tag, path) { + var script = doc.createElement(tag); + var scriptElement = doc.getElementsByTagName(tag)[0]; + script.src = pathtoroot + path; + scriptElement.parentNode.insertBefore(script, scriptElement); +} + +function show(type) { + count = 0; + for (var key in data) { + var row = document.getElementById(key); + if ((data[key] & type) !== 0) { + row.style.display = ''; + row.className = (count++ % 2) ? rowColor : altColor; + } + else + row.style.display = 'none'; + } + updateTabs(type); +} + +function updateTabs(type) { + for (var value in tabs) { + var sNode = document.getElementById(tabs[value][0]); + var spanNode = sNode.firstChild; + if (value == type) { + sNode.className = activeTableTab; + spanNode.innerHTML = tabs[value][1]; + } + else { + sNode.className = tableTab; + spanNode.innerHTML = "" + tabs[value][1] + ""; + } + } +} + +function updateModuleFrame(pFrame, cFrame) { + top.packageFrame.location = pFrame; + top.classFrame.location = cFrame; +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/stylesheet.css b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/stylesheet.css new file mode 100644 index 0000000..c027275 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/doc/stylesheet.css @@ -0,0 +1,906 @@ +/* + * Javadoc style sheet + */ + +@import url('resources/fonts/dejavu.css'); + +/* + * Styles for individual HTML elements. + * + * These are styles that are specific to individual HTML elements. Changing them affects the style of a particular + * HTML element throughout the page. + */ + +body { + background-color:#ffffff; + color:#353833; + font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; + font-size:14px; + margin:0; + padding:0; + height:100%; + width:100%; +} +iframe { + margin:0; + padding:0; + height:100%; + width:100%; + overflow-y:scroll; + border:none; +} +a:link, a:visited { + text-decoration:none; + color:#4A6782; +} +a[href]:hover, a[href]:focus { + text-decoration:none; + color:#bb7a2a; +} +a[name] { + color:#353833; +} +a[name]:before, a[name]:target, a[id]:before, a[id]:target { + content:""; + display:inline-block; + position:relative; + padding-top:129px; + margin-top:-129px; +} +pre { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; +} +h1 { + font-size:20px; +} +h2 { + font-size:18px; +} +h3 { + font-size:16px; + font-style:italic; +} +h4 { + font-size:13px; +} +h5 { + font-size:12px; +} +h6 { + font-size:11px; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; +} +table tr td dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} + +/* + * Styles for HTML generated by javadoc. + * + * These are style classes that are used by the standard doclet to generate HTML documentation. + */ + +/* + * Styles for document title and copyright. + */ +.clear { + clear:both; + height:0px; + overflow:hidden; +} +.aboutLanguage { + float:right; + padding:0px 21px; + font-size:11px; + z-index:200; + margin-top:-9px; +} +.legalCopy { + margin-left:.5em; +} +.bar a, .bar a:link, .bar a:visited, .bar a:active { + color:#FFFFFF; + text-decoration:none; +} +.bar a:hover, .bar a:focus { + color:#bb7a2a; +} +.tab { + background-color:#0066FF; + color:#ffffff; + padding:8px; + width:5em; + font-weight:bold; +} +/* + * Styles for navigation bar. + */ +.bar { + background-color:#4D7A97; + color:#FFFFFF; + padding:.8em .5em .4em .8em; + height:auto;/*height:1.8em;*/ + font-size:11px; + margin:0; +} +.navPadding { + padding-top: 107px; +} +.fixedNav { + position:fixed; + width:100%; + z-index:999; + background-color:#ffffff; +} +.topNav { + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.bottomNav { + margin-top:10px; + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.subNav { + background-color:#dee3e9; + float:left; + width:100%; + overflow:hidden; + font-size:12px; +} +.subNav div { + clear:left; + float:left; + padding:0 0 5px 6px; + text-transform:uppercase; +} +ul.navList, ul.subNavList { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.navList li{ + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +ul.navListSearch { + float:right; + margin:0 0 0 0; + padding:0; +} +ul.navListSearch li { + list-style:none; + float:right; + padding: 5px 6px; + text-transform:uppercase; +} +ul.navListSearch li label { + position:relative; + right:-16px; +} +ul.subNavList li { + list-style:none; + float:left; +} +.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { + color:#FFFFFF; + text-decoration:none; + text-transform:uppercase; +} +.topNav a:hover, .bottomNav a:hover { + text-decoration:none; + color:#bb7a2a; + text-transform:uppercase; +} +.navBarCell1Rev { + background-color:#F8981D; + color:#253441; + margin: auto 5px; +} +.skipNav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* + * Styles for page header and footer. + */ +.header, .footer { + clear:both; + margin:0 20px; + padding:5px 0 0 0; +} +.indexNav { + position:relative; + font-size:12px; + background-color:#dee3e9; +} +.indexNav ul { + margin-top:0; + padding:5px; +} +.indexNav ul li { + display:inline; + list-style-type:none; + padding-right:10px; + text-transform:uppercase; +} +.indexNav h1 { + font-size:13px; +} +.title { + color:#2c4557; + margin:10px 0; +} +.subTitle { + margin:5px 0 0 0; +} +.header ul { + margin:0 0 15px 0; + padding:0; +} +.footer ul { + margin:20px 0 5px 0; +} +.header ul li, .footer ul li { + list-style:none; + font-size:13px; +} +/* + * Styles for headings. + */ +div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList li.blockList h3 { + padding:0; + margin:15px 0; +} +ul.blockList li.blockList h2 { + padding:0px 0 20px 0; +} +/* + * Styles for page layout containers. + */ +.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer, +.allClassesContainer, .allPackagesContainer { + clear:both; + padding:10px 20px; + position:relative; +} +.indexContainer { + margin:10px; + position:relative; + font-size:12px; +} +.indexContainer h2 { + font-size:13px; + padding:0 0 3px 0; +} +.indexContainer ul { + margin:0; + padding:0; +} +.indexContainer ul li { + list-style:none; + padding-top:2px; +} +.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { + font-size:12px; + font-weight:bold; + margin:10px 0 0 0; + color:#4E4E4E; +} +.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { + margin:5px 0 10px 0px; + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} +.serializedFormContainer dl.nameValue dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +.serializedFormContainer dl.nameValue dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* + * Styles for lists. + */ +li.circle { + list-style:circle; +} +ul.horizontal li { + display:inline; + font-size:0.9em; +} +ul.inheritance { + margin:0; + padding:0; +} +ul.inheritance li { + display:inline; + list-style:none; +} +ul.inheritance li ul.inheritance { + margin-left:15px; + padding-left:15px; + padding-top:1px; +} +ul.blockList, ul.blockListLast { + margin:10px 0 10px 0; + padding:0; +} +ul.blockList li.blockList, ul.blockListLast li.blockList { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { + padding:0px 20px 5px 10px; + border:1px solid #ededed; + background-color:#f8f8f8; +} +ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { + padding:0 0 5px 8px; + background-color:#ffffff; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { + margin-left:0; + padding-left:0; + padding-bottom:15px; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { + list-style:none; + border-bottom:none; + padding-bottom:0; +} +table tr td dl, table tr td dl dt, table tr td dl dd { + margin-top:0; + margin-bottom:1px; +} +/* + * Styles for tables. + */ +.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary, +.requiresSummary, .packagesSummary, .providesSummary, .usesSummary { + width:100%; + border-spacing:0; + border-left:1px solid #EEE; + border-right:1px solid #EEE; + border-bottom:1px solid #EEE; +} +.overviewSummary, .memberSummary, .requiresSummary, .packagesSummary, .providesSummary, .usesSummary { + padding:0px; +} +.overviewSummary caption, .memberSummary caption, .typeSummary caption, +.useSummary caption, .constantsSummary caption, .deprecatedSummary caption, +.requiresSummary caption, .packagesSummary caption, .providesSummary caption, .usesSummary caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:#253441; + font-weight:bold; + clear:none; + overflow:hidden; + padding:0px; + padding-top:10px; + padding-left:1px; + margin:0px; + white-space:pre; +} +.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, +.constantsSummary caption a:link, .deprecatedSummary caption a:link, +.requiresSummary caption a:link, .packagesSummary caption a:link, .providesSummary caption a:link, +.usesSummary caption a:link, +.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, +.constantsSummary caption a:hover, .deprecatedSummary caption a:hover, +.requiresSummary caption a:hover, .packagesSummary caption a:hover, .providesSummary caption a:hover, +.usesSummary caption a:hover, +.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, +.constantsSummary caption a:active, .deprecatedSummary caption a:active, +.requiresSummary caption a:active, .packagesSummary caption a:active, .providesSummary caption a:active, +.usesSummary caption a:active, +.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, +.constantsSummary caption a:visited, .deprecatedSummary caption a:visited, +.requiresSummary caption a:visited, .packagesSummary caption a:visited, .providesSummary caption a:visited, +.usesSummary caption a:visited { + color:#FFFFFF; +} +.useSummary caption a:link, .useSummary caption a:hover, .useSummary caption a:active, +.useSummary caption a:visited { + color:#1f389c; +} +.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, +.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span, +.requiresSummary caption span, .packagesSummary caption span, .providesSummary caption span, +.usesSummary caption span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + padding-bottom:7px; + display:inline-block; + float:left; + background-color:#F8981D; + border: none; + height:16px; +} +.memberSummary caption span.activeTableTab span, .packagesSummary caption span.activeTableTab span, +.overviewSummary caption span.activeTableTab span, .typeSummary caption span.activeTableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#F8981D; + height:16px; +} +.memberSummary caption span.tableTab span, .packagesSummary caption span.tableTab span, +.overviewSummary caption span.tableTab span, .typeSummary caption span.tableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#4D7A97; + height:16px; +} +.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab, +.packagesSummary caption span.tableTab, .packagesSummary caption span.activeTableTab, +.overviewSummary caption span.tableTab, .overviewSummary caption span.activeTableTab, +.typeSummary caption span.tableTab, .typeSummary caption span.activeTableTab { + padding-top:0px; + padding-left:0px; + padding-right:0px; + background-image:none; + float:none; + display:inline; +} +.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, +.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd, +.requiresSummary .tabEnd, .packagesSummary .tabEnd, .providesSummary .tabEnd, .usesSummary .tabEnd { + display:none; + width:5px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .activeTableTab .tabEnd, .packagesSummary .activeTableTab .tabEnd, +.overviewSummary .activeTableTab .tabEnd, .typeSummary .activeTableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .tableTab .tabEnd, .packagesSummary .tableTab .tabEnd, +.overviewSummary .tableTab .tabEnd, .typeSummary .tableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + background-color:#4D7A97; + float:left; +} +.rowColor th, .altColor th { + font-weight:normal; +} +.overviewSummary td, .memberSummary td, .typeSummary td, +.useSummary td, .constantsSummary td, .deprecatedSummary td, +.requiresSummary td, .packagesSummary td, .providesSummary td, .usesSummary td { + text-align:left; + padding:0px 0px 12px 10px; +} +th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .useSummary th, +.constantsSummary th, .packagesSummary th, td.colFirst, td.colSecond, td.colLast, .useSummary td, +.constantsSummary td { + vertical-align:top; + padding-right:0px; + padding-top:8px; + padding-bottom:3px; +} +th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .constantsSummary th, +.packagesSummary th { + background:#dee3e9; + text-align:left; + padding:8px 3px 3px 7px; +} +td.colFirst, th.colFirst { + font-size:13px; +} +td.colSecond, th.colSecond, td.colLast, th.colConstructorName, th.colDeprecatedItemName, th.colLast { + font-size:13px; +} +.constantsSummary th, .packagesSummary th { + font-size:13px; +} +.providesSummary th.colFirst, .providesSummary th.colLast, .providesSummary td.colFirst, +.providesSummary td.colLast { + white-space:normal; + font-size:13px; +} +.overviewSummary td.colFirst, .overviewSummary th.colFirst, +.requiresSummary td.colFirst, .requiresSummary th.colFirst, +.packagesSummary td.colFirst, .packagesSummary td.colSecond, .packagesSummary th.colFirst, .packagesSummary th, +.usesSummary td.colFirst, .usesSummary th.colFirst, +.providesSummary td.colFirst, .providesSummary th.colFirst, +.memberSummary td.colFirst, .memberSummary th.colFirst, +.memberSummary td.colSecond, .memberSummary th.colSecond, .memberSummary th.colConstructorName, +.typeSummary td.colFirst, .typeSummary th.colFirst { + vertical-align:top; +} +.packagesSummary th.colLast, .packagesSummary td.colLast { + white-space:normal; +} +td.colFirst a:link, td.colFirst a:visited, +td.colSecond a:link, td.colSecond a:visited, +th.colFirst a:link, th.colFirst a:visited, +th.colSecond a:link, th.colSecond a:visited, +th.colConstructorName a:link, th.colConstructorName a:visited, +th.colDeprecatedItemName a:link, th.colDeprecatedItemName a:visited, +.constantValuesContainer td a:link, .constantValuesContainer td a:visited, +.allClassesContainer td a:link, .allClassesContainer td a:visited, +.allPackagesContainer td a:link, .allPackagesContainer td a:visited { + font-weight:bold; +} +.tableSubHeadingColor { + background-color:#EEEEFF; +} +.altColor, .altColor th { + background-color:#FFFFFF; +} +.rowColor, .rowColor th { + background-color:#EEEEEF; +} +/* + * Styles for contents. + */ +.description pre { + margin-top:0; +} +.deprecatedContent { + margin:0; + padding:10px 0; +} +.docSummary { + padding:0; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + font-style:normal; +} +div.block { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} +td.colLast div { + padding-top:0px; +} +td.colLast a { + padding-bottom:3px; +} +/* + * Styles for formatting effect. + */ +.sourceLineNo { + color:green; + padding:0 30px 0 0; +} +h1.hidden { + visibility:hidden; + overflow:hidden; + font-size:10px; +} +.block { + display:block; + margin:3px 10px 2px 0px; + color:#474747; +} +.deprecatedLabel, .descfrmTypeLabel, .implementationLabel, .memberNameLabel, .memberNameLink, +.moduleLabelInPackage, .moduleLabelInType, .overrideSpecifyLabel, .packageLabelInType, +.packageHierarchyLabel, .paramLabel, .returnLabel, .seeLabel, .simpleTagLabel, +.throwsLabel, .typeNameLabel, .typeNameLink, .searchTagLink { + font-weight:bold; +} +.deprecationComment, .emphasizedPhrase, .interfaceName { + font-style:italic; +} +.deprecationBlock { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; + border-style:solid; + border-width:thin; + border-radius:10px; + padding:10px; + margin-bottom:10px; + margin-right:10px; + display:inline-block; +} +div.block div.deprecationComment, div.block div.block span.emphasizedPhrase, +div.block div.block span.interfaceName { + font-style:normal; +} +div.contentContainer ul.blockList li.blockList h2 { + padding-bottom:0px; +} +/* + * Styles for IFRAME. + */ +.mainContainer { + margin:0 auto; + padding:0; + height:100%; + width:100%; + position:fixed; + top:0; + left:0; +} +.leftContainer { + height:100%; + position:fixed; + width:320px; +} +.leftTop { + position:relative; + float:left; + width:315px; + top:0; + left:0; + height:30%; + border-right:6px solid #ccc; + border-bottom:6px solid #ccc; +} +.leftBottom { + position:relative; + float:left; + width:315px; + bottom:0; + left:0; + height:70%; + border-right:6px solid #ccc; + border-top:1px solid #000; +} +.rightContainer { + position:absolute; + left:320px; + top:0; + bottom:0; + height:100%; + right:0; + border-left:1px solid #000; +} +.rightIframe { + margin:0; + padding:0; + height:100%; + right:30px; + width:100%; + overflow:visible; + margin-bottom:30px; +} +/* + * Styles specific to HTML5 elements. + */ +main, nav, header, footer, section { + display:block; +} +/* + * Styles for javadoc search. + */ +.ui-autocomplete-category { + font-weight:bold; + font-size:15px; + padding:7px 0 7px 3px; + background-color:#4D7A97; + color:#FFFFFF; +} +.resultItem { + font-size:13px; +} +.ui-autocomplete { + max-height:85%; + max-width:65%; + overflow-y:scroll; + overflow-x:scroll; + white-space:nowrap; + box-shadow: 0 3px 6px rgba(0,0,0,0.16), 0 3px 6px rgba(0,0,0,0.23); +} +ul.ui-autocomplete { + position:fixed; + z-index:999999; +} +ul.ui-autocomplete li { + float:left; + clear:both; + width:100%; +} +.resultHighlight { + font-weight:bold; +} +#search { + background-image:url('resources/glass.png'); + background-size:13px; + background-repeat:no-repeat; + background-position:2px 3px; + padding-left:20px; + position:relative; + right:-18px; +} +#reset { + background-color: rgb(255,255,255); + background-image:url('resources/x.png'); + background-position:center; + background-repeat:no-repeat; + background-size:12px; + border:0 none; + width:16px; + height:17px; + position:relative; + left:-4px; + top:-4px; + font-size:0px; +} +.watermark { + color:#545454; +} +.searchTagDescResult { + font-style:italic; + font-size:11px; +} +.searchTagHolderResult { + font-style:italic; + font-size:12px; +} +.searchTagResult:before, .searchTagResult:target { + color:red; +} +.moduleGraph span { + display:none; + position:absolute; +} +.moduleGraph:hover span { + display:block; + margin: -100px 0 0 100px; + z-index: 1; +} +.methodSignature { + white-space:normal; +} + +/* + * Styles for user-provided tables. + * + * borderless: + * No borders, vertical margins, styled caption. + * This style is provided for use with existing doc comments. + * In general, borderless tables should not be used for layout purposes. + * + * plain: + * Plain borders around table and cells, vertical margins, styled caption. + * Best for small tables or for complex tables for tables with cells that span + * rows and columns, when the "striped" style does not work well. + * + * striped: + * Borders around the table and vertical borders between cells, striped rows, + * vertical margins, styled caption. + * Best for tables that have a header row, and a body containing a series of simple rows. + */ + +table.borderless, +table.plain, +table.striped { + margin-top: 10px; + margin-bottom: 10px; +} +table.borderless > caption, +table.plain > caption, +table.striped > caption { + font-weight: bold; + font-size: smaller; +} +table.borderless th, table.borderless td, +table.plain th, table.plain td, +table.striped th, table.striped td { + padding: 2px 5px; +} +table.borderless, +table.borderless > thead > tr > th, table.borderless > tbody > tr > th, table.borderless > tr > th, +table.borderless > thead > tr > td, table.borderless > tbody > tr > td, table.borderless > tr > td { + border: none; +} +table.borderless > thead > tr, table.borderless > tbody > tr, table.borderless > tr { + background-color: transparent; +} +table.plain { + border-collapse: collapse; + border: 1px solid black; +} +table.plain > thead > tr, table.plain > tbody tr, table.plain > tr { + background-color: transparent; +} +table.plain > thead > tr > th, table.plain > tbody > tr > th, table.plain > tr > th, +table.plain > thead > tr > td, table.plain > tbody > tr > td, table.plain > tr > td { + border: 1px solid black; +} +table.striped { + border-collapse: collapse; + border: 1px solid black; +} +table.striped > thead { + background-color: #E3E3E3; +} +table.striped > thead > tr > th, table.striped > thead > tr > td { + border: 1px solid black; +} +table.striped > tbody > tr:nth-child(even) { + background-color: #EEE +} +table.striped > tbody > tr:nth-child(odd) { + background-color: #FFF +} +table.striped > tbody > tr > th, table.striped > tbody > tr > td { + border-left: 1px solid black; + border-right: 1px solid black; +} +table.striped > tbody > tr > th { + font-weight: normal; +} diff --git a/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/package.bluej b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/package.bluej new file mode 100644 index 0000000..51e33da --- /dev/null +++ b/Quellcodes/Alg_DS_Set/02_set_mit Sourcecode_roh/package.bluej @@ -0,0 +1,73 @@ +#BlueJ package file +dependency1.from=BenchmarkBase +dependency1.to=Set +dependency1.type=UsesDependency +dependency2.from=BenchmarkBase +dependency2.to=MeinBenchmark +dependency2.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1277 +editor.fx.0.x=42 +editor.fx.0.y=88 +objectbench.height=128 +objectbench.width=996 +package.divider.horizontal=0.654 +package.divider.vertical=0.7867298578199052 +package.editor.height=491 +package.editor.width=885 +package.editor.x=735 +package.editor.y=134 +package.frame.height=733 +package.frame.width=1036 +package.numDependencies=2 +package.numTargets=6 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=BenchmarkBase +target1.showInterface=true +target1.type=ClassTarget +target1.width=120 +target1.x=60 +target1.y=200 +target2.height=50 +target2.name=MeinBenchmark +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=150 +target2.y=300 +target3.height=50 +target3.name=Set +target3.showInterface=false +target3.type=AbstractTarget +target3.width=80 +target3.x=320 +target3.y=20 +target4.height=50 +target4.name=SetVarianteC +target4.showInterface=false +target4.type=ClassTarget +target4.width=110 +target4.x=440 +target4.y=190 +target5.height=50 +target5.name=SetVarianteB +target5.showInterface=false +target5.type=ClassTarget +target5.width=110 +target5.x=320 +target5.y=190 +target6.height=50 +target6.name=SetVarianteA +target6.showInterface=false +target6.type=ClassTarget +target6.width=110 +target6.x=200 +target6.y=190 diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/+libs/SizeOf.jar b/Quellcodes/Alg_DS_Set/03_set_loes/+libs/SizeOf.jar new file mode 100644 index 0000000..d1cc0f5 Binary files /dev/null and b/Quellcodes/Alg_DS_Set/03_set_loes/+libs/SizeOf.jar differ diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/+libs/license.txt b/Quellcodes/Alg_DS_Set/03_set_loes/+libs/license.txt new file mode 100644 index 0000000..eeb85a6 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/+libs/license.txt @@ -0,0 +1,3 @@ +Quelle: https://github.com/afeinberg/sizeof +GNU Public License 2.0 +Modifikationen von Rainer Helfrich \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/BenchmarkBase.java b/Quellcodes/Alg_DS_Set/03_set_loes/BenchmarkBase.java new file mode 100644 index 0000000..fde5186 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/BenchmarkBase.java @@ -0,0 +1,124 @@ +import java.util.*; +import net.sourceforge.sizeof.*; +import java.io.*; +import java.lang.reflect.*; + +/** + * Testet Set-Varianten auf ihre Effizenz + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class BenchmarkBase +{ + protected Set theSet; + Random zufallszahlen; + + protected BenchmarkBase() + { + zufallszahlen = new Random(); + } + + protected void init(Class c) throws Exception + { + theSet = (Set)c.newInstance(); + } + + /** + * Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + * Sollte nicht direkt aufgerufen werden. + */ + public static void main(String[] args) + { + try + { + int anzahl = Integer.parseInt(args[0]); + Class c = Class.forName(args[1]); + MeinBenchmark b = new MeinBenchmark(); + b.init(c); + Method m = b.getClass().getMethod(args[2], new Class[]{int.class}); + m.invoke(b, new Object[]{anzahl}); + System.out.println("@"+SizeOf.deepSizeOf((Object)b.theSet)+"@"); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + } + + /** + * Führt einen Laufzeittest aus. Wiederholt den Test 100 mal, um Ausreißer zu vermeiden. + * Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Laufzeit des Tests in Mikrosekunden (µs) + */ + protected static int laufzeitTest(String typ, String methode, int anzahl) + { + try + { + Class c = Class.forName(typ); + MeinBenchmark b = new MeinBenchmark(); + final int DURCHGAENGE = 100; + long totalTime = 0; + for (int i = 0; i < DURCHGAENGE; i++) + { + b.init(c); + Method m = b.getClass().getMethod(methode, new Class[]{int.class}); + long vorher = System.nanoTime(); + m.invoke(b, new Object[]{anzahl}); + long nachher = System.nanoTime(); + totalTime += (nachher - vorher) / 1000; + } + return (int)(totalTime / DURCHGAENGE); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } + + /** + * Führt einen Speichertest aus. Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Größe der Set in Bytes, nachdem die Testmethode ausgeführt wurde + */ + protected static int speicherTest(String typ, String methode, int anzahl) + { + try + { + Process process = new ProcessBuilder("java","-javaagent:./+libs/SizeOf.jar", MeinBenchmark.class.getName(), ""+anzahl, typ, methode).start(); + InputStream is = process.getInputStream(); + InputStreamReader isr = new InputStreamReader(is); + BufferedReader br = new BufferedReader(isr); + String line; + + StringBuilder sb = new StringBuilder(); + while ((line = br.readLine()) != null) { + sb.append(line); + } + String strOut = sb.toString(); + int idx = strOut.indexOf("@"); + if (idx < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int idx2 = strOut.indexOf("@", idx+1); + if (idx2 < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int n = Integer.parseInt(strOut.substring(idx+1, idx2)); + return n; + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } +} diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/MeinBenchmark.java b/Quellcodes/Alg_DS_Set/03_set_loes/MeinBenchmark.java new file mode 100644 index 0000000..011545c Binary files /dev/null and b/Quellcodes/Alg_DS_Set/03_set_loes/MeinBenchmark.java differ diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/README.TXT b/Quellcodes/Alg_DS_Set/03_set_loes/README.TXT new file mode 100644 index 0000000..fb73768 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Set-Benchmark +PROJEKTZWECK: Konstruieren Sie einen Benchmark, um herauszufinden, um welche Implementation es sich bei einer Set handelt. +VERSION oder DATUM: November 2020 +WIE IST DAS PROJEKT ZU STARTEN: Nachdem Sie in der Methode meinTest der Klasse MeinBenchmark einen Test definiert haben, rufen Sie eine der statischen Methoden speicherTestAusfuehren() oder laufzeitTestAusfuehren() auf. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/BenchmarkBase.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/BenchmarkBase.html new file mode 100644 index 0000000..8632eab --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/BenchmarkBase.html @@ -0,0 +1,307 @@ + + + + + +BenchmarkBase + + + + + + + + + +
+
+

Class BenchmarkBase

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • BenchmarkBase
      • +
    +
    • +
+
+
    +
  • +
    +
    public class BenchmarkBase
+extends java.lang.Object
    +
    Testet Set-Varianten auf ihre Effizenz
    +
    +
    Version:
    +
    November 2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Summary

      + + + + + + + + + + + + + + + + + +
      Fields 
      Modifier and TypeFieldDescription
      protected SettheSet 
      (package private) java.util.Randomzufallszahlen 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + + + +
      Constructors 
      ModifierConstructorDescription
      protected BenchmarkBase() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected voidinit​(java.lang.Class c) 
      protected static intlaufzeitTest​(java.lang.String typ, + java.lang.String methode, + int anzahl) +
      Führt einen Laufzeittest aus.
      +
      static voidmain​(java.lang.String[] args) +
      Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen.
      +
      protected static intspeicherTest​(java.lang.String typ, + java.lang.String methode, + int anzahl) +
      Führt einen Speichertest aus.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Detail

      + + + +
        +
      • +

        theSet

        +
        protected Set theSet
        +
        • +
      + + + +
        +
      • +

        zufallszahlen

        +
        java.util.Random zufallszahlen
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        BenchmarkBase

        +
        protected BenchmarkBase()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        init

        +
        protected void init​(java.lang.Class c)
+             throws java.lang.Exception
        +
        +
        Throws:
        +
        java.lang.Exception
        +
        +
        • +
      + + + +
        +
      • +

        main

        +
        public static void main​(java.lang.String[] args)
        +
        Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + Sollte nicht direkt aufgerufen werden.
        +
        • +
      + + + +
        +
      • +

        laufzeitTest

        +
        protected static int laufzeitTest​(java.lang.String typ,
+                                  java.lang.String methode,
+                                  int anzahl)
        +
        Führt einen Laufzeittest aus. Wiederholt den Test 100 mal, um Ausreißer zu vermeiden. + Sollte nicht direkt aufgerufen werden.
        +
        +
        Parameters:
        +
        typ - Die Unterklasse von Set, die getestet werden soll
        +
        methode - Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll
        +
        anzahl - Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert
        +
        Returns:
        +
        Die Laufzeit des Tests in Mikrosekunden (µs)
        +
        +
        • +
      + + + +
        +
      • +

        speicherTest

        +
        protected static int speicherTest​(java.lang.String typ,
+                                  java.lang.String methode,
+                                  int anzahl)
        +
        Führt einen Speichertest aus. Sollte nicht direkt aufgerufen werden.
        +
        +
        Parameters:
        +
        typ - Die Unterklasse von Set, die getestet werden soll
        +
        methode - Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll
        +
        anzahl - Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert
        +
        Returns:
        +
        Die Größe der Set in Bytes, nachdem die Testmethode ausgeführt wurde
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/MeinBenchmark.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/MeinBenchmark.html new file mode 100644 index 0000000..d309708 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/MeinBenchmark.html @@ -0,0 +1,230 @@ + + + + + +MeinBenchmark + + + + + + + + + +
+
+

Class MeinBenchmark

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • BenchmarkBase
      • +
    • +
        +
      • MeinBenchmark
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class MeinBenchmark
+extends BenchmarkBase
    +
    Führt Leistungstests mit verschiedenen Set-Implementationen aus
    +
    +
    Version:
    +
    November 2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Field Summary

      +
        +
      • + + +

        Fields inherited from class BenchmarkBase

        +theSet, zufallszahlen
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      MeinBenchmark() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      static voidlaufzeitTestAusfuehren() +
      Führt einen Laufzeittest mit 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus.
      +
      voidmeinTest​(int n) 
      static voidspeicherTestAusfuehren() +
      Führt einen Speichertest mit 100 Elementen aus und gibt das Ergebnis auf der Konsole aus.
      +
      +
        +
      • + + +

        Methods inherited from class BenchmarkBase

        +init, laufzeitTest, main, speicherTest
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        MeinBenchmark

        +
        public MeinBenchmark()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        meinTest

        +
        public void meinTest​(int n)
        +
        • +
      + + + +
        +
      • +

        speicherTestAusfuehren

        +
        public static void speicherTestAusfuehren()
        +
        Führt einen Speichertest mit 100 Elementen aus und gibt das Ergebnis auf der Konsole aus.
        +
        • +
      + + + +
        +
      • +

        laufzeitTestAusfuehren

        +
        public static void laufzeitTestAusfuehren()
        +
        Führt einen Laufzeittest mit 1000 Elementen aus und gibt das Ergebnis auf der Konsole aus.
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/Set.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/Set.html new file mode 100644 index 0000000..78c7413 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/Set.html @@ -0,0 +1,410 @@ + + + + + +Set + + + + + + + + + +
+
+

Class Set

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    +
    • +
+
+
    +
  • +
    +
    public abstract class Set
+extends java.lang.Object
    +
    Schnittstelle des ADTs Set
    +
    +
    Version:
    +
    26.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      Set() 
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected abstract int[]alsArray() 
      abstract intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      abstract Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      abstract voideinfuegen​(int wert) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      abstract voidentfernen​(int wert) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      abstract booleanenthaelt​(int wert) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleangleich​(Set s) +
      Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
      +
      abstract booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      abstract Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      java.lang.StringtoString() +
      Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück
      +
      abstract booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      abstract Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Set

        +
        public Set()
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        einfuegen

        +
        public abstract void einfuegen​(int wert)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public abstract void entfernen​(int wert)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public abstract boolean enthaelt​(int wert)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public abstract Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public abstract Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public abstract boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public abstract Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public abstract int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        istLeer

        +
        public abstract boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        alsArray

        +
        protected abstract int[] alsArray()
        +
        • +
      + + + +
        +
      • +

        gleich

        +
        public boolean gleich​(Set s)
        +
        Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
        +
        +
        Parameters:
        +
        s - Die zu überprüfende Menge
        +
        Returns:
        +
        true, wenn beide Mengen die gleichen Elemente enthalten; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        toString

        +
        public java.lang.String toString()
        +
        Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück
        +
        +
        Overrides:
        +
        toString in class java.lang.Object
        +
        Returns:
        +
        Ein String, der alle Elemente der Menge aufzählt.
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteA.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteA.html new file mode 100644 index 0000000..918de31 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteA.html @@ -0,0 +1,401 @@ + + + + + +SetVarianteA + + + + + + + + + +
+
+

Class SetVarianteA

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    • +
        +
      • SetVarianteA
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class SetVarianteA
+extends Set
    +
    Set-Variante A
    +
    +
    Version:
    +
    27.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      SetVarianteA() +
      Erzeugt eine neue leere Set
      +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected int[]alsArray() 
      intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      voideinfuegen​(int n) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      voidentfernen​(int n) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      booleanenthaelt​(int n) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class Set

        +gleich, toString
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SetVarianteA

        +
        public SetVarianteA()
        +
        Erzeugt eine neue leere Set
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        alsArray

        +
        protected int[] alsArray()
        +
        +
        Specified by:
        +
        alsArray in class Set
        +
        +
        • +
      + + + +
        +
      • +

        istLeer

        +
        public boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Specified by:
        +
        istLeer in class Set
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Specified by:
        +
        anzahl in class Set
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        differenz in class Set
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Specified by:
        +
        untermenge in class Set
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        vereinigungsmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        einfuegen

        +
        public void einfuegen​(int n)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Specified by:
        +
        einfuegen in class Set
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        schnittmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public boolean enthaelt​(int n)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Specified by:
        +
        enthaelt in class Set
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public void entfernen​(int n)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Specified by:
        +
        entfernen in class Set
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteB.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteB.html new file mode 100644 index 0000000..9e124f8 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteB.html @@ -0,0 +1,401 @@ + + + + + +SetVarianteB + + + + + + + + + +
+
+

Class SetVarianteB

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    • +
        +
      • SetVarianteB
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class SetVarianteB
+extends Set
    +
    Set-Variante B
    +
    +
    Version:
    +
    26.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      SetVarianteB() +
      Erzeugt eine neue leere Set
      +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected int[]alsArray() 
      intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      voideinfuegen​(int wert) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      voidentfernen​(int wert) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      booleanenthaelt​(int x) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class Set

        +gleich, toString
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SetVarianteB

        +
        public SetVarianteB()
        +
        Erzeugt eine neue leere Set
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        istLeer

        +
        public boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Specified by:
        +
        istLeer in class Set
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Specified by:
        +
        anzahl in class Set
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        differenz in class Set
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Specified by:
        +
        untermenge in class Set
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        vereinigungsmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        alsArray

        +
        protected int[] alsArray()
        +
        +
        Specified by:
        +
        alsArray in class Set
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        schnittmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public boolean enthaelt​(int x)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Specified by:
        +
        enthaelt in class Set
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public void entfernen​(int wert)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Specified by:
        +
        entfernen in class Set
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      + + + +
        +
      • +

        einfuegen

        +
        public void einfuegen​(int wert)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Specified by:
        +
        einfuegen in class Set
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteC.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteC.html new file mode 100644 index 0000000..6a86811 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/SetVarianteC.html @@ -0,0 +1,426 @@ + + + + + +SetVarianteC + + + + + + + + + +
+
+

Class SetVarianteC

+
+
+
    +
  • java.lang.Object
    • +
  • +
      +
    • Set
      • +
    • +
        +
      • SetVarianteC
        • +
      +
      • +
    +
    • +
+
+
    +
  • +
    +
    public class SetVarianteC
+extends Set
    +
    Set-Variante C
    +
    +
    Version:
    +
    26.9.2020
    +
    Author:
    +
    Rainer Helfrich
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Summary

      + + + + + + + + + + +
      Constructors 
      ConstructorDescription
      SetVarianteC() +
      Erzeugt eine neue leere Set
      +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Summary

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      All Methods Instance Methods Concrete Methods 
      Modifier and TypeMethodDescription
      protected int[]alsArray() 
      intanzahl() +
      Gibt die Mächtigkeit der Menge zurück
      +
      Setdifferenz​(Set s) +
      Bestimmt die Differenzmenge der Menge selbst und der Menge s.
      +
      voideinfuegen​(int x) +
      Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
      +
      voidentfernen​(int x) +
      Entfernt einen Wert aus der Menge, falls er enthalten ist.
      +
      booleanenthaelt​(int x) +
      Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
      +
      booleangleich​(Set s) +
      Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
      +
      booleanistLeer() +
      Gibt zurück, ob die Menge kein Element enthält
      +
      Setschnittmenge​(Set s) +
      Bestimmt die Schnittmenge der Menge selbst und der Menge s.
      +
      booleanuntermenge​(Set s) +
      Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
      +
      Setvereinigungsmenge​(Set s) +
      Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
      +
      +
        +
      • + + +

        Methods inherited from class Set

        +toString
        • +
      +
        +
      • + + +

        Methods inherited from class java.lang.Object

        +clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
        • +
      +
      • +
    +
    +
    • +
+
+
+
    +
  • + +
    +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        SetVarianteC

        +
        public SetVarianteC()
        +
        Erzeugt eine neue leere Set
        +
        • +
      +
      • +
    +
    + +
    +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        alsArray

        +
        protected int[] alsArray()
        +
        +
        Specified by:
        +
        alsArray in class Set
        +
        +
        • +
      + + + +
        +
      • +

        istLeer

        +
        public boolean istLeer()
        +
        Gibt zurück, ob die Menge kein Element enthält
        +
        +
        Specified by:
        +
        istLeer in class Set
        +
        Returns:
        +
        true, wenn die Menge leer ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        enthaelt

        +
        public boolean enthaelt​(int x)
        +
        Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
        +
        +
        Specified by:
        +
        enthaelt in class Set
        +
        Parameters:
        +
        wert - Der zu suchende Wert
        +
        +
        • +
      + + + +
        +
      • +

        anzahl

        +
        public int anzahl()
        +
        Gibt die Mächtigkeit der Menge zurück
        +
        +
        Specified by:
        +
        anzahl in class Set
        +
        Returns:
        +
        Die Anzahl der Elemente in der Menge
        +
        +
        • +
      + + + +
        +
      • +

        differenz

        +
        public Set differenz​(Set s)
        +
        Bestimmt die Differenzmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        differenz in class Set
        +
        Parameters:
        +
        s - Die Menge, die von dieser Menge abgezogen werden soll.
        +
        Returns:
        +
        Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
        +
        +
        • +
      + + + +
        +
      • +

        einfuegen

        +
        public void einfuegen​(int x)
        +
        Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
        +
        +
        Specified by:
        +
        einfuegen in class Set
        +
        Parameters:
        +
        wert - Der einzufügende Wert
        +
        +
        • +
      + + + +
        +
      • +

        untermenge

        +
        public boolean untermenge​(Set s)
        +
        Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
        +
        +
        Specified by:
        +
        untermenge in class Set
        +
        Parameters:
        +
        s - Die Menge, die geprüft werden soll.
        +
        Returns:
        +
        true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
        +
        +
        • +
      + + + +
        +
      • +

        vereinigungsmenge

        +
        public Set vereinigungsmenge​(Set s)
        +
        Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        vereinigungsmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        schnittmenge

        +
        public Set schnittmenge​(Set s)
        +
        Bestimmt die Schnittmenge der Menge selbst und der Menge s.
        +
        +
        Specified by:
        +
        schnittmenge in class Set
        +
        Parameters:
        +
        s - Die Menge, mit der die Schnittmenge bestimmt werden soll
        +
        Returns:
        +
        Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert.
        +
        +
        • +
      + + + +
        +
      • +

        entfernen

        +
        public void entfernen​(int x)
        +
        Entfernt einen Wert aus der Menge, falls er enthalten ist.
        +
        +
        Specified by:
        +
        entfernen in class Set
        +
        Parameters:
        +
        wert - Der zu entfernende Wert
        +
        +
        • +
      + + + +
        +
      • +

        gleich

        +
        public boolean gleich​(Set s)
        +
        Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten
        +
        +
        Overrides:
        +
        gleich in class Set
        +
        Parameters:
        +
        s - Die zu überprüfende Menge
        +
        Returns:
        +
        true, wenn beide Mengen die gleichen Elemente enthalten; false sonst
        +
        +
        • +
      +
      • +
    +
    +
    • +
+
+
+
+ + + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/allclasses.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/allclasses.html new file mode 100644 index 0000000..595ef81 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/allclasses.html @@ -0,0 +1,20 @@ + + + + + +All Classes + + + + + + +

All Classes

+
+ +
+ + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/constant-values.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/constant-values.html new file mode 100644 index 0000000..1771f3f --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/constant-values.html @@ -0,0 +1,35 @@ + + + + + +Constant Field Values + + + + + + + + +
+
+

Constant Field Values

+
+

Contents

+
+
+
+ + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/element-list b/Quellcodes/Alg_DS_Set/03_set_loes/doc/element-list new file mode 100644 index 0000000..0e722c7 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/element-list @@ -0,0 +1 @@ +unnamed package diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/index.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/index.html new file mode 100644 index 0000000..cd12d84 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/index.html @@ -0,0 +1,23 @@ + + + + + +Generated Documentation (Untitled) + + + + + + + +
+ +

SetVarianteC.html

+
+ + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/logfile.txt b/Quellcodes/Alg_DS_Set/03_set_loes/doc/logfile.txt new file mode 100644 index 0000000..c13cdec --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/logfile.txt @@ -0,0 +1,40 @@ +Class documentation +<---- javadoc command: ----> +D:\Program Files\BlueJ\jdk\bin\javadoc.exe +-author +-version +-nodeprecated +-package +-Xdoclint:none +-noindex +-notree +-nohelp +-nonavbar +-source +11 +-classpath +D:\Program Files\BlueJ\lib\bluejcore.jar;D:\Program Files\BlueJ\lib\junit-4.11.jar;D:\Program Files\BlueJ\lib\hamcrest-core-1.3.jar;D:\Program Files\BlueJ\lib\lang-stride.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.base.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.controls.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.fxml.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.graphics.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.media.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.properties.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.swing.jar;D:\Program Files\BlueJ\lib\javafx\lib\javafx.web.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\Weiterentwicklung der Informatik ab 2015\Eigener Ablauf\Regionaltag 9+10\Turtle - Lösung\aplu5.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\+libs\SizeOf.jar;D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode) +-d +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc +-encoding +UTF-8 +-charset +UTF-8 +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java +<---- end of javadoc command ----> +Loading source file D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java... +Constructing Javadoc information... +Standard Doclet version 11.0.2 +Building tree for all the packages and classes... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\SetVarianteC.html... +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java:54: warning - @param argument "wert" is not a parameter name. +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java:117: warning - @param argument "wert" is not a parameter name. +D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\SetVarianteC.java:243: warning - @param argument "wert" is not a parameter name. +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\package-summary.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\constant-values.html... +Building index for all the packages and classes... +Building index for all classes... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\allclasses.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\allclasses.html... +Generating D:\Users\LeRainieur\Documents\Schule\Fortbildungen\ZPG Oberstufe\ADTs\Ergebnis\3_vorlagen_tauschordner\04_set (mit Sourcecode)\doc\index.html... +3 warnings diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/package-summary.html b/Quellcodes/Alg_DS_Set/03_set_loes/doc/package-summary.html new file mode 100644 index 0000000..987db39 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/package-summary.html @@ -0,0 +1,53 @@ + + + + + +<Unnamed> + + + + + + + + +
+
+

Package <Unnamed>

+
+
+
    +
  • + + + + + + + + + + + + +
    Class Summary 
    ClassDescription
    SetVarianteC +
    Set-Variante C
    +
    +
    • +
+
+
+ + diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/script.js b/Quellcodes/Alg_DS_Set/03_set_loes/doc/script.js new file mode 100644 index 0000000..d33d3ab --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/script.js @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +var moduleSearchIndex; +var packageSearchIndex; +var typeSearchIndex; +var memberSearchIndex; +var tagSearchIndex; +function loadScripts(doc, tag) { + createElem(doc, tag, 'jquery/jszip/dist/jszip.js'); + createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils.js'); + if (window.navigator.userAgent.indexOf('MSIE ') > 0 || window.navigator.userAgent.indexOf('Trident/') > 0 || + window.navigator.userAgent.indexOf('Edge/') > 0) { + createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils-ie.js'); + } + createElem(doc, tag, 'search.js'); + + $.get(pathtoroot + "module-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "module-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + moduleSearchIndex = JSON.parse(zip.file("module-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "package-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "package-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + packageSearchIndex = JSON.parse(zip.file("package-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "type-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "type-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + typeSearchIndex = JSON.parse(zip.file("type-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "member-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "member-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + memberSearchIndex = JSON.parse(zip.file("member-search-index.json").asText()); + }); + }); + $.get(pathtoroot + "tag-search-index.zip") + .done(function() { + JSZipUtils.getBinaryContent(pathtoroot + "tag-search-index.zip", function(e, data) { + var zip = new JSZip(data); + zip.load(data); + tagSearchIndex = JSON.parse(zip.file("tag-search-index.json").asText()); + }); + }); + if (!moduleSearchIndex) { + createElem(doc, tag, 'module-search-index.js'); + } + if (!packageSearchIndex) { + createElem(doc, tag, 'package-search-index.js'); + } + if (!typeSearchIndex) { + createElem(doc, tag, 'type-search-index.js'); + } + if (!memberSearchIndex) { + createElem(doc, tag, 'member-search-index.js'); + } + if (!tagSearchIndex) { + createElem(doc, tag, 'tag-search-index.js'); + } + $(window).resize(function() { + $('.navPadding').css('padding-top', $('.fixedNav').css("height")); + }); +} + +function createElem(doc, tag, path) { + var script = doc.createElement(tag); + var scriptElement = doc.getElementsByTagName(tag)[0]; + script.src = pathtoroot + path; + scriptElement.parentNode.insertBefore(script, scriptElement); +} + +function show(type) { + count = 0; + for (var key in data) { + var row = document.getElementById(key); + if ((data[key] & type) !== 0) { + row.style.display = ''; + row.className = (count++ % 2) ? rowColor : altColor; + } + else + row.style.display = 'none'; + } + updateTabs(type); +} + +function updateTabs(type) { + for (var value in tabs) { + var sNode = document.getElementById(tabs[value][0]); + var spanNode = sNode.firstChild; + if (value == type) { + sNode.className = activeTableTab; + spanNode.innerHTML = tabs[value][1]; + } + else { + sNode.className = tableTab; + spanNode.innerHTML = "" + tabs[value][1] + ""; + } + } +} + +function updateModuleFrame(pFrame, cFrame) { + top.packageFrame.location = pFrame; + top.classFrame.location = cFrame; +} diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/doc/stylesheet.css b/Quellcodes/Alg_DS_Set/03_set_loes/doc/stylesheet.css new file mode 100644 index 0000000..c027275 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/doc/stylesheet.css @@ -0,0 +1,906 @@ +/* + * Javadoc style sheet + */ + +@import url('resources/fonts/dejavu.css'); + +/* + * Styles for individual HTML elements. + * + * These are styles that are specific to individual HTML elements. Changing them affects the style of a particular + * HTML element throughout the page. + */ + +body { + background-color:#ffffff; + color:#353833; + font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; + font-size:14px; + margin:0; + padding:0; + height:100%; + width:100%; +} +iframe { + margin:0; + padding:0; + height:100%; + width:100%; + overflow-y:scroll; + border:none; +} +a:link, a:visited { + text-decoration:none; + color:#4A6782; +} +a[href]:hover, a[href]:focus { + text-decoration:none; + color:#bb7a2a; +} +a[name] { + color:#353833; +} +a[name]:before, a[name]:target, a[id]:before, a[id]:target { + content:""; + display:inline-block; + position:relative; + padding-top:129px; + margin-top:-129px; +} +pre { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; +} +h1 { + font-size:20px; +} +h2 { + font-size:18px; +} +h3 { + font-size:16px; + font-style:italic; +} +h4 { + font-size:13px; +} +h5 { + font-size:12px; +} +h6 { + font-size:11px; +} +ul { + list-style-type:disc; +} +code, tt { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; + margin-top:8px; + line-height:1.4em; +} +dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + padding-top:4px; +} +table tr td dt code { + font-family:'DejaVu Sans Mono', monospace; + font-size:14px; + vertical-align:top; + padding-top:4px; +} +sup { + font-size:8px; +} + +/* + * Styles for HTML generated by javadoc. + * + * These are style classes that are used by the standard doclet to generate HTML documentation. + */ + +/* + * Styles for document title and copyright. + */ +.clear { + clear:both; + height:0px; + overflow:hidden; +} +.aboutLanguage { + float:right; + padding:0px 21px; + font-size:11px; + z-index:200; + margin-top:-9px; +} +.legalCopy { + margin-left:.5em; +} +.bar a, .bar a:link, .bar a:visited, .bar a:active { + color:#FFFFFF; + text-decoration:none; +} +.bar a:hover, .bar a:focus { + color:#bb7a2a; +} +.tab { + background-color:#0066FF; + color:#ffffff; + padding:8px; + width:5em; + font-weight:bold; +} +/* + * Styles for navigation bar. + */ +.bar { + background-color:#4D7A97; + color:#FFFFFF; + padding:.8em .5em .4em .8em; + height:auto;/*height:1.8em;*/ + font-size:11px; + margin:0; +} +.navPadding { + padding-top: 107px; +} +.fixedNav { + position:fixed; + width:100%; + z-index:999; + background-color:#ffffff; +} +.topNav { + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.bottomNav { + margin-top:10px; + background-color:#4D7A97; + color:#FFFFFF; + float:left; + padding:0; + width:100%; + clear:right; + height:2.8em; + padding-top:10px; + overflow:hidden; + font-size:12px; +} +.subNav { + background-color:#dee3e9; + float:left; + width:100%; + overflow:hidden; + font-size:12px; +} +.subNav div { + clear:left; + float:left; + padding:0 0 5px 6px; + text-transform:uppercase; +} +ul.navList, ul.subNavList { + float:left; + margin:0 25px 0 0; + padding:0; +} +ul.navList li{ + list-style:none; + float:left; + padding: 5px 6px; + text-transform:uppercase; +} +ul.navListSearch { + float:right; + margin:0 0 0 0; + padding:0; +} +ul.navListSearch li { + list-style:none; + float:right; + padding: 5px 6px; + text-transform:uppercase; +} +ul.navListSearch li label { + position:relative; + right:-16px; +} +ul.subNavList li { + list-style:none; + float:left; +} +.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { + color:#FFFFFF; + text-decoration:none; + text-transform:uppercase; +} +.topNav a:hover, .bottomNav a:hover { + text-decoration:none; + color:#bb7a2a; + text-transform:uppercase; +} +.navBarCell1Rev { + background-color:#F8981D; + color:#253441; + margin: auto 5px; +} +.skipNav { + position:absolute; + top:auto; + left:-9999px; + overflow:hidden; +} +/* + * Styles for page header and footer. + */ +.header, .footer { + clear:both; + margin:0 20px; + padding:5px 0 0 0; +} +.indexNav { + position:relative; + font-size:12px; + background-color:#dee3e9; +} +.indexNav ul { + margin-top:0; + padding:5px; +} +.indexNav ul li { + display:inline; + list-style-type:none; + padding-right:10px; + text-transform:uppercase; +} +.indexNav h1 { + font-size:13px; +} +.title { + color:#2c4557; + margin:10px 0; +} +.subTitle { + margin:5px 0 0 0; +} +.header ul { + margin:0 0 15px 0; + padding:0; +} +.footer ul { + margin:20px 0 5px 0; +} +.header ul li, .footer ul li { + list-style:none; + font-size:13px; +} +/* + * Styles for headings. + */ +div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + background-color:#dee3e9; + border:1px solid #d0d9e0; + margin:0 0 6px -8px; + padding:7px 5px; +} +ul.blockList ul.blockList li.blockList h3 { + padding:0; + margin:15px 0; +} +ul.blockList li.blockList h2 { + padding:0px 0 20px 0; +} +/* + * Styles for page layout containers. + */ +.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer, +.allClassesContainer, .allPackagesContainer { + clear:both; + padding:10px 20px; + position:relative; +} +.indexContainer { + margin:10px; + position:relative; + font-size:12px; +} +.indexContainer h2 { + font-size:13px; + padding:0 0 3px 0; +} +.indexContainer ul { + margin:0; + padding:0; +} +.indexContainer ul li { + list-style:none; + padding-top:2px; +} +.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { + font-size:12px; + font-weight:bold; + margin:10px 0 0 0; + color:#4E4E4E; +} +.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { + margin:5px 0 10px 0px; + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} +.serializedFormContainer dl.nameValue dt { + margin-left:1px; + font-size:1.1em; + display:inline; + font-weight:bold; +} +.serializedFormContainer dl.nameValue dd { + margin:0 0 0 1px; + font-size:1.1em; + display:inline; +} +/* + * Styles for lists. + */ +li.circle { + list-style:circle; +} +ul.horizontal li { + display:inline; + font-size:0.9em; +} +ul.inheritance { + margin:0; + padding:0; +} +ul.inheritance li { + display:inline; + list-style:none; +} +ul.inheritance li ul.inheritance { + margin-left:15px; + padding-left:15px; + padding-top:1px; +} +ul.blockList, ul.blockListLast { + margin:10px 0 10px 0; + padding:0; +} +ul.blockList li.blockList, ul.blockListLast li.blockList { + list-style:none; + margin-bottom:15px; + line-height:1.4; +} +ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { + padding:0px 20px 5px 10px; + border:1px solid #ededed; + background-color:#f8f8f8; +} +ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { + padding:0 0 5px 8px; + background-color:#ffffff; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { + margin-left:0; + padding-left:0; + padding-bottom:15px; + border:none; +} +ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { + list-style:none; + border-bottom:none; + padding-bottom:0; +} +table tr td dl, table tr td dl dt, table tr td dl dd { + margin-top:0; + margin-bottom:1px; +} +/* + * Styles for tables. + */ +.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary, +.requiresSummary, .packagesSummary, .providesSummary, .usesSummary { + width:100%; + border-spacing:0; + border-left:1px solid #EEE; + border-right:1px solid #EEE; + border-bottom:1px solid #EEE; +} +.overviewSummary, .memberSummary, .requiresSummary, .packagesSummary, .providesSummary, .usesSummary { + padding:0px; +} +.overviewSummary caption, .memberSummary caption, .typeSummary caption, +.useSummary caption, .constantsSummary caption, .deprecatedSummary caption, +.requiresSummary caption, .packagesSummary caption, .providesSummary caption, .usesSummary caption { + position:relative; + text-align:left; + background-repeat:no-repeat; + color:#253441; + font-weight:bold; + clear:none; + overflow:hidden; + padding:0px; + padding-top:10px; + padding-left:1px; + margin:0px; + white-space:pre; +} +.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, +.constantsSummary caption a:link, .deprecatedSummary caption a:link, +.requiresSummary caption a:link, .packagesSummary caption a:link, .providesSummary caption a:link, +.usesSummary caption a:link, +.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, +.constantsSummary caption a:hover, .deprecatedSummary caption a:hover, +.requiresSummary caption a:hover, .packagesSummary caption a:hover, .providesSummary caption a:hover, +.usesSummary caption a:hover, +.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, +.constantsSummary caption a:active, .deprecatedSummary caption a:active, +.requiresSummary caption a:active, .packagesSummary caption a:active, .providesSummary caption a:active, +.usesSummary caption a:active, +.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, +.constantsSummary caption a:visited, .deprecatedSummary caption a:visited, +.requiresSummary caption a:visited, .packagesSummary caption a:visited, .providesSummary caption a:visited, +.usesSummary caption a:visited { + color:#FFFFFF; +} +.useSummary caption a:link, .useSummary caption a:hover, .useSummary caption a:active, +.useSummary caption a:visited { + color:#1f389c; +} +.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, +.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span, +.requiresSummary caption span, .packagesSummary caption span, .providesSummary caption span, +.usesSummary caption span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + padding-bottom:7px; + display:inline-block; + float:left; + background-color:#F8981D; + border: none; + height:16px; +} +.memberSummary caption span.activeTableTab span, .packagesSummary caption span.activeTableTab span, +.overviewSummary caption span.activeTableTab span, .typeSummary caption span.activeTableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#F8981D; + height:16px; +} +.memberSummary caption span.tableTab span, .packagesSummary caption span.tableTab span, +.overviewSummary caption span.tableTab span, .typeSummary caption span.tableTab span { + white-space:nowrap; + padding-top:5px; + padding-left:12px; + padding-right:12px; + margin-right:3px; + display:inline-block; + float:left; + background-color:#4D7A97; + height:16px; +} +.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab, +.packagesSummary caption span.tableTab, .packagesSummary caption span.activeTableTab, +.overviewSummary caption span.tableTab, .overviewSummary caption span.activeTableTab, +.typeSummary caption span.tableTab, .typeSummary caption span.activeTableTab { + padding-top:0px; + padding-left:0px; + padding-right:0px; + background-image:none; + float:none; + display:inline; +} +.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, +.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd, +.requiresSummary .tabEnd, .packagesSummary .tabEnd, .providesSummary .tabEnd, .usesSummary .tabEnd { + display:none; + width:5px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .activeTableTab .tabEnd, .packagesSummary .activeTableTab .tabEnd, +.overviewSummary .activeTableTab .tabEnd, .typeSummary .activeTableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + float:left; + background-color:#F8981D; +} +.memberSummary .tableTab .tabEnd, .packagesSummary .tableTab .tabEnd, +.overviewSummary .tableTab .tabEnd, .typeSummary .tableTab .tabEnd { + display:none; + width:5px; + margin-right:3px; + position:relative; + background-color:#4D7A97; + float:left; +} +.rowColor th, .altColor th { + font-weight:normal; +} +.overviewSummary td, .memberSummary td, .typeSummary td, +.useSummary td, .constantsSummary td, .deprecatedSummary td, +.requiresSummary td, .packagesSummary td, .providesSummary td, .usesSummary td { + text-align:left; + padding:0px 0px 12px 10px; +} +th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .useSummary th, +.constantsSummary th, .packagesSummary th, td.colFirst, td.colSecond, td.colLast, .useSummary td, +.constantsSummary td { + vertical-align:top; + padding-right:0px; + padding-top:8px; + padding-bottom:3px; +} +th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .constantsSummary th, +.packagesSummary th { + background:#dee3e9; + text-align:left; + padding:8px 3px 3px 7px; +} +td.colFirst, th.colFirst { + font-size:13px; +} +td.colSecond, th.colSecond, td.colLast, th.colConstructorName, th.colDeprecatedItemName, th.colLast { + font-size:13px; +} +.constantsSummary th, .packagesSummary th { + font-size:13px; +} +.providesSummary th.colFirst, .providesSummary th.colLast, .providesSummary td.colFirst, +.providesSummary td.colLast { + white-space:normal; + font-size:13px; +} +.overviewSummary td.colFirst, .overviewSummary th.colFirst, +.requiresSummary td.colFirst, .requiresSummary th.colFirst, +.packagesSummary td.colFirst, .packagesSummary td.colSecond, .packagesSummary th.colFirst, .packagesSummary th, +.usesSummary td.colFirst, .usesSummary th.colFirst, +.providesSummary td.colFirst, .providesSummary th.colFirst, +.memberSummary td.colFirst, .memberSummary th.colFirst, +.memberSummary td.colSecond, .memberSummary th.colSecond, .memberSummary th.colConstructorName, +.typeSummary td.colFirst, .typeSummary th.colFirst { + vertical-align:top; +} +.packagesSummary th.colLast, .packagesSummary td.colLast { + white-space:normal; +} +td.colFirst a:link, td.colFirst a:visited, +td.colSecond a:link, td.colSecond a:visited, +th.colFirst a:link, th.colFirst a:visited, +th.colSecond a:link, th.colSecond a:visited, +th.colConstructorName a:link, th.colConstructorName a:visited, +th.colDeprecatedItemName a:link, th.colDeprecatedItemName a:visited, +.constantValuesContainer td a:link, .constantValuesContainer td a:visited, +.allClassesContainer td a:link, .allClassesContainer td a:visited, +.allPackagesContainer td a:link, .allPackagesContainer td a:visited { + font-weight:bold; +} +.tableSubHeadingColor { + background-color:#EEEEFF; +} +.altColor, .altColor th { + background-color:#FFFFFF; +} +.rowColor, .rowColor th { + background-color:#EEEEEF; +} +/* + * Styles for contents. + */ +.description pre { + margin-top:0; +} +.deprecatedContent { + margin:0; + padding:10px 0; +} +.docSummary { + padding:0; +} +ul.blockList ul.blockList ul.blockList li.blockList h3 { + font-style:normal; +} +div.block { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; +} +td.colLast div { + padding-top:0px; +} +td.colLast a { + padding-bottom:3px; +} +/* + * Styles for formatting effect. + */ +.sourceLineNo { + color:green; + padding:0 30px 0 0; +} +h1.hidden { + visibility:hidden; + overflow:hidden; + font-size:10px; +} +.block { + display:block; + margin:3px 10px 2px 0px; + color:#474747; +} +.deprecatedLabel, .descfrmTypeLabel, .implementationLabel, .memberNameLabel, .memberNameLink, +.moduleLabelInPackage, .moduleLabelInType, .overrideSpecifyLabel, .packageLabelInType, +.packageHierarchyLabel, .paramLabel, .returnLabel, .seeLabel, .simpleTagLabel, +.throwsLabel, .typeNameLabel, .typeNameLink, .searchTagLink { + font-weight:bold; +} +.deprecationComment, .emphasizedPhrase, .interfaceName { + font-style:italic; +} +.deprecationBlock { + font-size:14px; + font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; + border-style:solid; + border-width:thin; + border-radius:10px; + padding:10px; + margin-bottom:10px; + margin-right:10px; + display:inline-block; +} +div.block div.deprecationComment, div.block div.block span.emphasizedPhrase, +div.block div.block span.interfaceName { + font-style:normal; +} +div.contentContainer ul.blockList li.blockList h2 { + padding-bottom:0px; +} +/* + * Styles for IFRAME. + */ +.mainContainer { + margin:0 auto; + padding:0; + height:100%; + width:100%; + position:fixed; + top:0; + left:0; +} +.leftContainer { + height:100%; + position:fixed; + width:320px; +} +.leftTop { + position:relative; + float:left; + width:315px; + top:0; + left:0; + height:30%; + border-right:6px solid #ccc; + border-bottom:6px solid #ccc; +} +.leftBottom { + position:relative; + float:left; + width:315px; + bottom:0; + left:0; + height:70%; + border-right:6px solid #ccc; + border-top:1px solid #000; +} +.rightContainer { + position:absolute; + left:320px; + top:0; + bottom:0; + height:100%; + right:0; + border-left:1px solid #000; +} +.rightIframe { + margin:0; + padding:0; + height:100%; + right:30px; + width:100%; + overflow:visible; + margin-bottom:30px; +} +/* + * Styles specific to HTML5 elements. + */ +main, nav, header, footer, section { + display:block; +} +/* + * Styles for javadoc search. + */ +.ui-autocomplete-category { + font-weight:bold; + font-size:15px; + padding:7px 0 7px 3px; + background-color:#4D7A97; + color:#FFFFFF; +} +.resultItem { + font-size:13px; +} +.ui-autocomplete { + max-height:85%; + max-width:65%; + overflow-y:scroll; + overflow-x:scroll; + white-space:nowrap; + box-shadow: 0 3px 6px rgba(0,0,0,0.16), 0 3px 6px rgba(0,0,0,0.23); +} +ul.ui-autocomplete { + position:fixed; + z-index:999999; +} +ul.ui-autocomplete li { + float:left; + clear:both; + width:100%; +} +.resultHighlight { + font-weight:bold; +} +#search { + background-image:url('resources/glass.png'); + background-size:13px; + background-repeat:no-repeat; + background-position:2px 3px; + padding-left:20px; + position:relative; + right:-18px; +} +#reset { + background-color: rgb(255,255,255); + background-image:url('resources/x.png'); + background-position:center; + background-repeat:no-repeat; + background-size:12px; + border:0 none; + width:16px; + height:17px; + position:relative; + left:-4px; + top:-4px; + font-size:0px; +} +.watermark { + color:#545454; +} +.searchTagDescResult { + font-style:italic; + font-size:11px; +} +.searchTagHolderResult { + font-style:italic; + font-size:12px; +} +.searchTagResult:before, .searchTagResult:target { + color:red; +} +.moduleGraph span { + display:none; + position:absolute; +} +.moduleGraph:hover span { + display:block; + margin: -100px 0 0 100px; + z-index: 1; +} +.methodSignature { + white-space:normal; +} + +/* + * Styles for user-provided tables. + * + * borderless: + * No borders, vertical margins, styled caption. + * This style is provided for use with existing doc comments. + * In general, borderless tables should not be used for layout purposes. + * + * plain: + * Plain borders around table and cells, vertical margins, styled caption. + * Best for small tables or for complex tables for tables with cells that span + * rows and columns, when the "striped" style does not work well. + * + * striped: + * Borders around the table and vertical borders between cells, striped rows, + * vertical margins, styled caption. + * Best for tables that have a header row, and a body containing a series of simple rows. + */ + +table.borderless, +table.plain, +table.striped { + margin-top: 10px; + margin-bottom: 10px; +} +table.borderless > caption, +table.plain > caption, +table.striped > caption { + font-weight: bold; + font-size: smaller; +} +table.borderless th, table.borderless td, +table.plain th, table.plain td, +table.striped th, table.striped td { + padding: 2px 5px; +} +table.borderless, +table.borderless > thead > tr > th, table.borderless > tbody > tr > th, table.borderless > tr > th, +table.borderless > thead > tr > td, table.borderless > tbody > tr > td, table.borderless > tr > td { + border: none; +} +table.borderless > thead > tr, table.borderless > tbody > tr, table.borderless > tr { + background-color: transparent; +} +table.plain { + border-collapse: collapse; + border: 1px solid black; +} +table.plain > thead > tr, table.plain > tbody tr, table.plain > tr { + background-color: transparent; +} +table.plain > thead > tr > th, table.plain > tbody > tr > th, table.plain > tr > th, +table.plain > thead > tr > td, table.plain > tbody > tr > td, table.plain > tr > td { + border: 1px solid black; +} +table.striped { + border-collapse: collapse; + border: 1px solid black; +} +table.striped > thead { + background-color: #E3E3E3; +} +table.striped > thead > tr > th, table.striped > thead > tr > td { + border: 1px solid black; +} +table.striped > tbody > tr:nth-child(even) { + background-color: #EEE +} +table.striped > tbody > tr:nth-child(odd) { + background-color: #FFF +} +table.striped > tbody > tr > th, table.striped > tbody > tr > td { + border-left: 1px solid black; + border-right: 1px solid black; +} +table.striped > tbody > tr > th { + font-weight: normal; +} diff --git a/Quellcodes/Alg_DS_Set/03_set_loes/package.bluej b/Quellcodes/Alg_DS_Set/03_set_loes/package.bluej new file mode 100644 index 0000000..2b81f35 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/03_set_loes/package.bluej @@ -0,0 +1,73 @@ +#BlueJ package file +dependency1.from=BenchmarkBase +dependency1.to=Set +dependency1.type=UsesDependency +dependency2.from=BenchmarkBase +dependency2.to=MeinBenchmark +dependency2.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1221 +editor.fx.0.x=552 +editor.fx.0.y=100 +objectbench.height=128 +objectbench.width=996 +package.divider.horizontal=0.654 +package.divider.vertical=0.7867298578199052 +package.editor.height=491 +package.editor.width=885 +package.editor.x=469 +package.editor.y=133 +package.frame.height=733 +package.frame.width=1036 +package.numDependencies=2 +package.numTargets=6 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=BenchmarkBase +target1.showInterface=false +target1.type=ClassTarget +target1.width=120 +target1.x=60 +target1.y=200 +target2.height=50 +target2.name=MeinBenchmark +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=150 +target2.y=300 +target3.height=50 +target3.name=Set +target3.showInterface=false +target3.type=AbstractTarget +target3.width=80 +target3.x=320 +target3.y=20 +target4.height=50 +target4.name=SetVarianteC +target4.showInterface=false +target4.type=ClassTarget +target4.width=110 +target4.x=440 +target4.y=190 +target5.height=50 +target5.name=SetVarianteB +target5.showInterface=false +target5.type=ClassTarget +target5.width=110 +target5.x=320 +target5.y=190 +target6.height=50 +target6.name=SetVarianteA +target6.showInterface=false +target6.type=ClassTarget +target6.width=110 +target6.x=200 +target6.y=190 diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/+libs/SizeOf.jar b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/+libs/SizeOf.jar new file mode 100644 index 0000000..d1cc0f5 Binary files /dev/null and b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/+libs/SizeOf.jar differ diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/+libs/license.txt b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/+libs/license.txt new file mode 100644 index 0000000..eeb85a6 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/+libs/license.txt @@ -0,0 +1,3 @@ +Quelle: https://github.com/afeinberg/sizeof +GNU Public License 2.0 +Modifikationen von Rainer Helfrich \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/BenchmarkBase.java b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/BenchmarkBase.java new file mode 100644 index 0000000..fde5186 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/BenchmarkBase.java @@ -0,0 +1,124 @@ +import java.util.*; +import net.sourceforge.sizeof.*; +import java.io.*; +import java.lang.reflect.*; + +/** + * Testet Set-Varianten auf ihre Effizenz + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class BenchmarkBase +{ + protected Set theSet; + Random zufallszahlen; + + protected BenchmarkBase() + { + zufallszahlen = new Random(); + } + + protected void init(Class c) throws Exception + { + theSet = (Set)c.newInstance(); + } + + /** + * Wird benötigt, um in einem neuen Prozess den Speichertest durchzuführen. + * Sollte nicht direkt aufgerufen werden. + */ + public static void main(String[] args) + { + try + { + int anzahl = Integer.parseInt(args[0]); + Class c = Class.forName(args[1]); + MeinBenchmark b = new MeinBenchmark(); + b.init(c); + Method m = b.getClass().getMethod(args[2], new Class[]{int.class}); + m.invoke(b, new Object[]{anzahl}); + System.out.println("@"+SizeOf.deepSizeOf((Object)b.theSet)+"@"); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + } + + /** + * Führt einen Laufzeittest aus. Wiederholt den Test 100 mal, um Ausreißer zu vermeiden. + * Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Laufzeit des Tests in Mikrosekunden (µs) + */ + protected static int laufzeitTest(String typ, String methode, int anzahl) + { + try + { + Class c = Class.forName(typ); + MeinBenchmark b = new MeinBenchmark(); + final int DURCHGAENGE = 100; + long totalTime = 0; + for (int i = 0; i < DURCHGAENGE; i++) + { + b.init(c); + Method m = b.getClass().getMethod(methode, new Class[]{int.class}); + long vorher = System.nanoTime(); + m.invoke(b, new Object[]{anzahl}); + long nachher = System.nanoTime(); + totalTime += (nachher - vorher) / 1000; + } + return (int)(totalTime / DURCHGAENGE); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } + + /** + * Führt einen Speichertest aus. Sollte nicht direkt aufgerufen werden. + * @param typ Die Unterklasse von Set, die getestet werden soll + * @param methode Der Name der Methode in der Klasse MeinBenchmark, die zum Testen ausgeführt werden soll + * @param anzahl Ein Parameter für die Methode namens "methode", der z.B. die Anzahl der Operationen steuert + * @return Die Größe der Set in Bytes, nachdem die Testmethode ausgeführt wurde + */ + protected static int speicherTest(String typ, String methode, int anzahl) + { + try + { + Process process = new ProcessBuilder("java","-javaagent:./+libs/SizeOf.jar", MeinBenchmark.class.getName(), ""+anzahl, typ, methode).start(); + InputStream is = process.getInputStream(); + InputStreamReader isr = new InputStreamReader(is); + BufferedReader br = new BufferedReader(isr); + String line; + + StringBuilder sb = new StringBuilder(); + while ((line = br.readLine()) != null) { + sb.append(line); + } + String strOut = sb.toString(); + int idx = strOut.indexOf("@"); + if (idx < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int idx2 = strOut.indexOf("@", idx+1); + if (idx2 < 0) + { + throw new Exception("Fehler: Ungültige Ausgabe:\n"+strOut); + } + int n = Integer.parseInt(strOut.substring(idx+1, idx2)); + return n; + } + catch(Exception x) + { + System.out.println(x.getMessage()); + } + return -1; + } +} diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/MeinBenchmark.java b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/MeinBenchmark.java new file mode 100644 index 0000000..338219f Binary files /dev/null and b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/MeinBenchmark.java differ diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/README.TXT b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/README.TXT new file mode 100644 index 0000000..fb73768 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Set-Benchmark +PROJEKTZWECK: Konstruieren Sie einen Benchmark, um herauszufinden, um welche Implementation es sich bei einer Set handelt. +VERSION oder DATUM: November 2020 +WIE IST DAS PROJEKT ZU STARTEN: Nachdem Sie in der Methode meinTest der Klasse MeinBenchmark einen Test definiert haben, rufen Sie eine der statischen Methoden speicherTestAusfuehren() oder laufzeitTestAusfuehren() auf. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/Set.java b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/Set.java new file mode 100644 index 0000000..753b99d --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/Set.java @@ -0,0 +1,107 @@ +/** + * Schnittstelle des ADTs Set + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ + +public abstract class Set +{ + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public abstract void einfuegen(int wert); + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public abstract void entfernen(int wert); + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public abstract boolean enthaelt(int wert); + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public abstract Set schnittmenge(Set s); + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public abstract Set vereinigungsmenge(Set s); + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public abstract boolean untermenge(Set s); + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public abstract Set differenz(Set s); + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public abstract int anzahl(); + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public abstract boolean istLeer(); + + protected abstract int[] alsArray(); + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + return untermenge(s) && s.untermenge(this); + } + + /** + * Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück + * @return Ein String, der alle Elemente der Menge aufzählt. + */ + @Override + public String toString() + { + if (istLeer()) + { + return "{ }"; + } + StringBuilder sb = new StringBuilder(); + for(int v : alsArray()) + { + if (sb.length() == 0) + { + sb.append("{ "); + } + else + { + sb.append(", "); + } + sb.append(v); + } + sb.append(" }"); + return sb.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteA.java b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteA.java new file mode 100644 index 0000000..677e24e --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteA.java @@ -0,0 +1,240 @@ +import java.util.ArrayList; + +/** + * Set-Variante A + * + * @author Rainer Helfrich + * @version 27.9.2020 + */ +public class SetVarianteA extends Set +{ + private ArrayList[] daten; + private int anzahl; + + /** + * Erzeugt ein neues leeres Set + */ + public SetVarianteA() + { + this(10); + } + + private SetVarianteA(int capacity) + { + if (capacity < 10) + { + capacity = 10; + } + daten = new ArrayList[capacity*2]; + anzahl = 0; + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl]; + int index = 0; + for (ArrayList l : daten) + { + if (l != null) + { + for (int x : l) + { + ergebnis[index] = x; + index++; + } + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + for (ArrayList l : daten) + { + if (l != null && !l.isEmpty()) + { + return false; + } + } + return true; + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + return anzahl; + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + Set ergebnis = new SetVarianteA(anzahl); + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + if (!s.enthaelt(n)) + { + ergebnis.einfuegen(n); + } + } + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + if (!s.enthaelt(n)) + { + return false; + } + } + } + } + return true; + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + SetVarianteA ergebnis = new SetVarianteA(s.anzahl() + anzahl()); + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + ergebnis.einfuegen(n); + } + } + } + for (int n : s.alsArray()) + { + ergebnis.einfuegen(n); + } + return ergebnis; + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int n) + { + if ((double)anzahl / daten.length > 0.5) + { + rehash(); + } + int hash = n % daten.length; + if (daten[hash] == null) + { + daten[hash] = new ArrayList(2); + } + if (!daten[hash].contains(n)) + { + anzahl++; + daten[hash].add(n); + } + } + + private void rehash() + { + ArrayList[] tmp = new ArrayList[2*daten.length+1]; + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + int hash = n % tmp.length; + if (tmp[hash] == null) + { + tmp[hash] = new ArrayList(2); + } + tmp[hash].add(n); + } + } + } + daten = tmp; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + SetVarianteA ergebnis = new SetVarianteA(anzahl); + for (ArrayList l : daten) + { + if (l != null) + { + for (int n : l) + { + if (s.enthaelt(n)) + { + ergebnis.einfuegen(n); + } + } + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int n) + { + int hash = n % daten.length; + return daten[hash] != null && daten[hash].contains(n); + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int n) + { + int hash = n % daten.length; + if (daten[hash] != null) + { + if (daten[hash].contains(n)) + { + anzahl--; + daten[hash].remove(new Integer(n)); + } + } + } +} diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteB.java b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteB.java new file mode 100644 index 0000000..d36bcc9 --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteB.java @@ -0,0 +1,151 @@ +import java.util.ArrayList; + +/** + * Set-Variante B + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ +public class SetVarianteB extends Set +{ + private ArrayList daten; + + /** + * Erzeugt ein neues leeres Set + */ + public SetVarianteB() + { + daten = new ArrayList(); + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + return daten.isEmpty(); + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + return daten.size(); + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + Set ergebnis = new SetVarianteB(); + for(int v : daten) + { + if (!s.enthaelt(v)) + { + ergebnis.einfuegen(v); + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + for (int v : daten) + { + if (!s.enthaelt(v)) + { + return false; + } + } + return true; + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + Set ergebnis = new SetVarianteB(); + for (int v : daten) + { + ergebnis.einfuegen(v); + } + for (int v : s.alsArray()) + { + ergebnis.einfuegen(v); + } + return ergebnis; + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl()]; + for (int i = 0; i < anzahl(); i++) + { + ergebnis[i] = daten.get(i); + } + return ergebnis; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + Set ergebnis = new SetVarianteB(); + for (int v : daten) + { + if (s.enthaelt(v)) + { + ergebnis.einfuegen(v); + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int x) + { + return daten.contains(x); + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int wert) + { + daten.remove(new Integer(wert)); + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int wert) + { + if (!daten.contains(wert)) + { + daten.add(wert); + } + } + +} diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteC.java b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteC.java new file mode 100644 index 0000000..f64179c --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/SetVarianteC.java @@ -0,0 +1,294 @@ +import java.util.ArrayList; + +/** + * Set-Variante C + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ +public class SetVarianteC extends Set +{ + private ArrayList daten; + + /** + * Erzeugt ein neues leeres Set + */ + public SetVarianteC() + { + daten = new ArrayList(); + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl()]; + int index = 0; + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i)) + { + ergebnis[index] = i; + index++; + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + for (int v : daten) + { + if (v != 0) + { + return false; + } + } + return true; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int x) + { + if (x >= 32*daten.size() || x < 0) + { + return false; + } + int i = x / 32; + int j = x % 32; + int mask = 1 << j; + return (daten.get(i) & mask) != 0; + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + int laenge = 0; + for (int i : daten) + { + laenge += Integer.bitCount(i); + } + return laenge; + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + SetVarianteC ergebnis = new SetVarianteC(); + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & ~(bs.daten.get(i))); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int x) + { + if (x >= 0) + { + int i = x / 32; + daten.ensureCapacity(i+1); + while(i >= daten.size()) + { + daten.add(0); + } + int j = x % 32; + int mask = 1 << j; + daten.set(i, daten.get(i) | mask); + } + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + int a = daten.get(i); + int b = bs.daten.get(i); + if ((a & ~b) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + return false; + } + } + return true; + } + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + SetVarianteC ergebnis = new SetVarianteC(); + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) | bs.daten.get(i)); + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + ergebnis.daten.add(bs.daten.get(i)); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + int[] a = s.alsArray(); + ergebnis.daten.addAll(daten); + for (int n : a) + { + ergebnis.einfuegen(n); + } + } + return ergebnis; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + SetVarianteC ergebnis = new SetVarianteC(); + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & bs.daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int x) + { + if (x < 32*daten.size() && x >= 0) + { + int i = x / 32; + int j = x % 32; + int mask = ~(1 << j); + daten.set(i, daten.get(i) & mask); + } + } + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + if (s instanceof SetVarianteC) + { + SetVarianteC bs = (SetVarianteC)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + if (daten.get(i) != bs.daten.get(i)) + { + return false; + } + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + if (bs.daten.get(i) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + return super.gleich(s); + } + } +} diff --git a/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/package.bluej b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/package.bluej new file mode 100644 index 0000000..a0235cb --- /dev/null +++ b/Quellcodes/Alg_DS_Set/04_set_mitSourcecode_loes/package.bluej @@ -0,0 +1,73 @@ +#BlueJ package file +dependency1.from=BenchmarkBase +dependency1.to=Set +dependency1.type=UsesDependency +dependency2.from=BenchmarkBase +dependency2.to=MeinBenchmark +dependency2.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1439 +editor.fx.0.x=310 +editor.fx.0.y=51 +objectbench.height=128 +objectbench.width=996 +package.divider.horizontal=0.654 +package.divider.vertical=0.7867298578199052 +package.editor.height=491 +package.editor.width=885 +package.editor.x=469 +package.editor.y=133 +package.frame.height=733 +package.frame.width=1036 +package.numDependencies=2 +package.numTargets=6 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=60 +readme.name=@README +readme.width=49 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=BenchmarkBase +target1.showInterface=false +target1.type=ClassTarget +target1.width=120 +target1.x=60 +target1.y=200 +target2.height=50 +target2.name=MeinBenchmark +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=150 +target2.y=300 +target3.height=50 +target3.name=Set +target3.showInterface=false +target3.type=AbstractTarget +target3.width=80 +target3.x=320 +target3.y=20 +target4.height=50 +target4.name=SetVarianteC +target4.showInterface=false +target4.type=ClassTarget +target4.width=110 +target4.x=440 +target4.y=190 +target5.height=50 +target5.name=SetVarianteB +target5.showInterface=false +target5.type=ClassTarget +target5.width=110 +target5.x=320 +target5.y=190 +target6.height=50 +target6.name=SetVarianteA +target6.showInterface=false +target6.type=ClassTarget +target6.width=110 +target6.x=200 +target6.y=190 diff --git a/Quellcodes/Alg_DS_Set/readme.adoc b/Quellcodes/Alg_DS_Set/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Set/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Snake/.gitignore b/Quellcodes/Alg_DS_Snake/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/Apple.java b/Quellcodes/Alg_DS_Snake/01_snake_roh/Apple.java new file mode 100644 index 0000000..b274a15 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/01_snake_roh/Apple.java @@ -0,0 +1,12 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) + +/** + * Stellt einen Apfel dar, den die Schlange fressen soll + * + * @author Rainer Helfrich + * @version April 2020 + */ +public class Apple extends Actor +{ + +} diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/Queue.java b/Quellcodes/Alg_DS_Snake/01_snake_roh/Queue.java new file mode 100644 index 0000000..7e60a9f --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/01_snake_roh/Queue.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Queues + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Queue +{ + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public abstract void enqueue(T x); + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public abstract T dequeue(); + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public abstract T front(); +} diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/README.TXT b/Quellcodes/Alg_DS_Snake/01_snake_roh/README.TXT new file mode 100644 index 0000000..53661eb --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/01_snake_roh/README.TXT @@ -0,0 +1,7 @@ +PROJECT TITLE: Snake +PURPOSE OF PROJECT: Implementieren Sie ein Snake-Spiel +VERSION or DATE: April 2020 +HOW TO START THIS PROJECT: Klicken Sie nach dem Kompilieren auf "Run" und drücken Sie die Leertaste +AUTHORS: Rainer Helfrich, ZPG Informatik + +Verwendete Bilder aus der Greenfoot-Bibliothek diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/Snake.java b/Quellcodes/Alg_DS_Snake/01_snake_roh/Snake.java new file mode 100644 index 0000000..07b398e --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/01_snake_roh/Snake.java @@ -0,0 +1,102 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) +import java.util.List; + +/** + * Die Schlange, die vom Spieler gesteuert wird + * + * @author Rainer Helfrich + * @version April 2020 + */ +public class Snake extends Actor +{ + /** + * Die Queue, die die Körperelemente enthält + */ + private Queue theQueue; + + /** + * Die aktuelle Bewegungsrichtung der Schlange + */ + private char richtung; + + /** + * Konstanten für die vier Bewegungsrichtungen + */ + private final char OBEN = 'w'; + private final char UNTEN = 's'; + private final char LINKS = 'a'; + private final char RECHTS = 'd'; + + /** + * Erzeugt eine neue Schlange und platziert sie in der Welt. + */ + public Snake(World w) + { + //# TODO: Erzeugen Sie eine neue Queue + + //# Ende TODO + if (theQueue != null) + { + SnakeElement el = new SnakeElement(); + w.addObject(el, 15, 10); + theQueue.enqueue(el); + el = new SnakeElement(); + w.addObject(el, 14, 10); + theQueue.enqueue(el); + } + richtung = RECHTS; + } + + /** + * Prüft, ob die Taste zum Buchstaben c gedrückt ist + * @param c Die Taste, die überprüft wird + * @return true, wenn die Taste gedrückt ist; false sonst + */ + private boolean isKeyDown(char c) + { + return Greenfoot.isKeyDown(""+c); + } + + /** + * Wird in jedem Zeitschritt aufgerufen + */ + public void act() + { + if (isKeyDown(OBEN) && richtung != UNTEN) + { + richtung = OBEN; + } + else if (isKeyDown(UNTEN) && richtung != OBEN) + { + richtung = UNTEN; + } + else if (isKeyDown(LINKS) && richtung != RECHTS) + { + richtung = LINKS; + } + else if (isKeyDown(RECHTS) && richtung != LINKS) + { + richtung = RECHTS; + } + SnakeWorld sw = (SnakeWorld)getWorld(); + + int x = getX(); + int y = getY(); + //# TODO + //# Bestimmen Sie die neue Position (x,y) der Schlange + //# Achtung: Was passiert, wenn die Schlange aus dem Spielfeld herausfährt? + + //# Finden Sie heraus, ob sich an der Position des Kopfes ein Apfel befindet + + //# Wenn ja, entfernen Sie den Apfel aus der Welt und platzieren Sie einen neuen Apfel in der Welt. + + //# Wenn nein: Befindet sich ein Körperteil der Schlange an der Position des Kopfes? Wenn ja, ist das Spiel verloren. + + //# Wenn auch das nicht der Fall ist, wird nur der letzte Teil des Schwanzes entfernt. + + //# In jedem Fall wird an der neuen Position ein neuer Kopf erzeugt und in die Schlange eingefügt. + //# Ende TODO + + setLocation(x, y); + } +} diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/SnakeElement.java b/Quellcodes/Alg_DS_Snake/01_snake_roh/SnakeElement.java new file mode 100644 index 0000000..41ebdc1 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/01_snake_roh/SnakeElement.java @@ -0,0 +1,12 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) + +/** + * Ein Körperelement der Schlange + * + * @author Rainer Helfrich + * @version April 2020 + */ +public class SnakeElement extends Actor +{ + +} diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/SnakeWorld.java b/Quellcodes/Alg_DS_Snake/01_snake_roh/SnakeWorld.java new file mode 100644 index 0000000..e255cbc --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/01_snake_roh/SnakeWorld.java @@ -0,0 +1,71 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) + +/** + * Die Welt, in der sich die Schlange bewegt + * + * @author Rainer Helfrich + * @version 2020-04-08 + */ +public class SnakeWorld extends World +{ + /** + * Die Ausführungsgeschwindigkeit + */ + private int speed; + + /** + * Erzeugt eine neue Welt + */ + public SnakeWorld() + { + super(30, 20, 20); + } + + /** + * Platziert einen neuen Apfel an einer freien Stelle in der Welt + */ + public void placeApple() + { + Apple a = new Apple(); + int x, y; + do + { + x = Greenfoot.getRandomNumber(getWidth()); + y = Greenfoot.getRandomNumber(getHeight()); + } while (getObjectsAt(x, y, SnakeElement.class).size() > 0); + addObject(a, x, y); + if (speed < 49) // danach nicht mehr spielbar + { + speed++; + Greenfoot.setSpeed(speed); + } + } + + /** + * Wird aufgerufen, wenn das Spiel verloren ist. + * Zeigt eine Nachricht und die Punktezahl an. + */ + public void setGameOver() + { + int points = getObjects(SnakeElement.class).size() - 2; + removeObjects(getObjects(null)); + getBackground().drawImage(new GreenfootImage("Game over", 64, null, null), 170, 130); + getBackground().drawImage(new GreenfootImage("Punkte: " + points, 40, null, null), 220, 220); + } + + /** + * Wartet auf das Drücken der Leertaste, um das Spiel zu initialisieren + */ + public void act() + { + if (Greenfoot.isKeyDown("space") && + getObjects(Snake.class).isEmpty()) + { + setBackground((GreenfootImage)null); + Snake s = new Snake(this); + addObject(s, 15,10); + speed = 22; + placeApple(); + } + } +} diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/images/apple1.png b/Quellcodes/Alg_DS_Snake/01_snake_roh/images/apple1.png new file mode 100644 index 0000000..9b65806 Binary files /dev/null and b/Quellcodes/Alg_DS_Snake/01_snake_roh/images/apple1.png differ diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/images/ball.png b/Quellcodes/Alg_DS_Snake/01_snake_roh/images/ball.png new file mode 100644 index 0000000..3888933 Binary files /dev/null and b/Quellcodes/Alg_DS_Snake/01_snake_roh/images/ball.png differ diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/images/transparent.png b/Quellcodes/Alg_DS_Snake/01_snake_roh/images/transparent.png new file mode 100644 index 0000000..d406af6 Binary files /dev/null and b/Quellcodes/Alg_DS_Snake/01_snake_roh/images/transparent.png differ diff --git a/Quellcodes/Alg_DS_Snake/01_snake_roh/project.greenfoot b/Quellcodes/Alg_DS_Snake/01_snake_roh/project.greenfoot new file mode 100644 index 0000000..3eccba2 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/01_snake_roh/project.greenfoot @@ -0,0 +1,83 @@ +#Greenfoot project file +class.Apple.image=apple1.png +class.Snake.image=transparent.png +class.SnakeElement.image=ball.png +dependency1.from=SnakeWorld +dependency1.to=Apple +dependency1.type=UsesDependency +dependency2.from=SnakeWorld +dependency2.to=Snake +dependency2.type=UsesDependency +dependency3.from=SnakeWorld +dependency3.to=SnakeElement +dependency3.type=UsesDependency +dependency4.from=Snake +dependency4.to=Queue +dependency4.type=UsesDependency +dependency5.from=Snake +dependency5.to=SnakeElement +dependency5.type=UsesDependency +dependency6.from=Snake +dependency6.to=SnakeWorld +dependency6.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1195 +editor.fx.0.x=552 +editor.fx.0.y=100 +height=795 +package.numDependencies=6 +package.numTargets=5 +project.charset=UTF-8 +publish.hasSource=false +publish.locked=true +publish.longDesc= +publish.shortDesc= +publish.tags= +publish.title= +publish.url= +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +simulation.speed=68 +target1.height=50 +target1.name=Apple +target1.showInterface=false +target1.type=ClassTarget +target1.width=80 +target1.x=0 +target1.y=0 +target2.height=50 +target2.name=SnakeElement +target2.showInterface=false +target2.type=ClassTarget +target2.width=100 +target2.x=0 +target2.y=0 +target3.height=50 +target3.name=Snake +target3.showInterface=false +target3.type=ClassTarget +target3.width=80 +target3.x=0 +target3.y=0 +target4.height=50 +target4.name=SnakeWorld +target4.showInterface=false +target4.type=ClassTarget +target4.width=90 +target4.x=0 +target4.y=0 +target5.height=50 +target5.name=Queue +target5.showInterface=false +target5.type=AbstractTarget +target5.width=80 +target5.x=0 +target5.y=0 +version=3.0.0 +width=1175 +world.lastInstantiated=SnakeWorld +xPosition=15 +yPosition=44 diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/Apple.java b/Quellcodes/Alg_DS_Snake/02_snake_loes/Apple.java new file mode 100644 index 0000000..b274a15 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/Apple.java @@ -0,0 +1,12 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) + +/** + * Stellt einen Apfel dar, den die Schlange fressen soll + * + * @author Rainer Helfrich + * @version April 2020 + */ +public class Apple extends Actor +{ + +} diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/ArrayQueue.java b/Quellcodes/Alg_DS_Snake/02_snake_loes/ArrayQueue.java new file mode 100644 index 0000000..c34e0cd --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/ArrayQueue.java @@ -0,0 +1,124 @@ + +/** + * Queue basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayQueue extends Queue +{ + /** + * Die Nutzdaten + */ + private Object[] daten; + + /** + * Der Index des ersten Wertes + */ + private int first; + + /** + * Der nächste freie Index + */ + private int last; + + /** + * Erzeugt eine neue, leere Queue + */ + public ArrayQueue() + { + daten = new Object[10]; + first = 0; + last = 0; + } + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public void enqueue(T x) + { + daten[last] = x; + last++; + if (last == daten.length) + { + last = 0; + } + if (last == first) // Vergrößerung nötig + { + Object[] tmp = new Object[daten.length*2]; + System.arraycopy(daten, first, tmp, 0, daten.length - first); + System.arraycopy(daten, 0, tmp, daten.length - first, first); + first = 0; + last = daten.length; + daten = tmp; + } + } + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public T front() + { + if (isEmpty()) + { + return null; + } + return (T)daten[first]; + } + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public T dequeue() + { + T x = null; + if (!isEmpty()) + { + x = (T)daten[first]; + first++; + if (first == daten.length) + { + first = 0; + } + } + return x; + } + + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public boolean isEmpty() + { + return first == last; + } + + /** + * Gibt die Queue in String-Form aus. + * @return Die String-Repräsentation der Queue + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + for (int i = first; i < (last < first ? daten.length : last); i++) + { + if (i != first) + { + b.append(", "); + } + b.append(daten[i]); + } + if (last < first) + { + for (int i = 0; i < last; i++) + { + b.append(", " + daten[i]); + } + } + return "< " + b.toString() + " <"; + } +} diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/Queue.java b/Quellcodes/Alg_DS_Snake/02_snake_loes/Queue.java new file mode 100644 index 0000000..7e60a9f --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/Queue.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Queues + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Queue +{ + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public abstract void enqueue(T x); + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public abstract T dequeue(); + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public abstract T front(); +} diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/README.TXT b/Quellcodes/Alg_DS_Snake/02_snake_loes/README.TXT new file mode 100644 index 0000000..53661eb --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/README.TXT @@ -0,0 +1,7 @@ +PROJECT TITLE: Snake +PURPOSE OF PROJECT: Implementieren Sie ein Snake-Spiel +VERSION or DATE: April 2020 +HOW TO START THIS PROJECT: Klicken Sie nach dem Kompilieren auf "Run" und drücken Sie die Leertaste +AUTHORS: Rainer Helfrich, ZPG Informatik + +Verwendete Bilder aus der Greenfoot-Bibliothek diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/Snake.java b/Quellcodes/Alg_DS_Snake/02_snake_loes/Snake.java new file mode 100644 index 0000000..153a2c2 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/Snake.java @@ -0,0 +1,131 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) +import java.util.List; + +/** + * Die Schlange, die vom Spieler gesteuert wird + * + * @author Rainer Helfrich + * @version April 2020 + */ +public class Snake extends Actor +{ + /** + * Die Queue, die die Körperelemente enthält + */ + private Queue theQueue; + + /** + * Die aktuelle Bewegungsrichtung der Schlange + */ + private char richtung; + + /** + * Konstanten für die vier Bewegungsrichtungen + */ + private final char OBEN = 'w'; + private final char UNTEN = 's'; + private final char LINKS = 'a'; + private final char RECHTS = 'd'; + + /** + * Erzeugt eine neue Schlange und platziert sie in der Welt. + */ + public Snake(World w) + { + theQueue = new ArrayQueue(); + SnakeElement el = new SnakeElement(); + w.addObject(el, 15, 10); + theQueue.enqueue(el); + el = new SnakeElement(); + w.addObject(el, 14, 10); + theQueue.enqueue(el); + richtung = RECHTS; + } + + /** + * Prüft, ob die Taste zum Buchstaben c gedrückt ist + * @param c Die Taste, die überprüft wird + * @return true, wenn die Taste gedrückt ist; false sonst + */ + private boolean isKeyDown(char c) + { + return Greenfoot.isKeyDown(""+c); + } + + private int neuePosition(int p, int g) + { + if (p < 0) + { + p += g; + } + return p % g; + } + + /** + * Wird in jedem Zeitschritt aufgerufen + */ + public void act() + { + if (isKeyDown(OBEN) && richtung != UNTEN) + { + richtung = OBEN; + } + else if (isKeyDown(UNTEN) && richtung != OBEN) + { + richtung = UNTEN; + } + else if (isKeyDown(LINKS) && richtung != RECHTS) + { + richtung = LINKS; + } + else if (isKeyDown(RECHTS) && richtung != LINKS) + { + richtung = RECHTS; + } + SnakeWorld sw = (SnakeWorld)getWorld(); + + int x = getX(); + int y = getY(); + if (richtung == OBEN) + { + y--; + } + else if (richtung == UNTEN) + { + y++; + } + else if (richtung == LINKS) + { + x--; + } + else if (richtung == RECHTS) + { + x++; + } + x = neuePosition(x, getWorld().getWidth()); + y = neuePosition(y, getWorld().getHeight()); + + List apples = sw.getObjectsAt(x, y, Apple.class); + SnakeElement el; + if (!apples.isEmpty()) + { + Apple a = apples.get(0); + sw.removeObject(a); + sw.placeApple(); + } + else + { + el = theQueue.dequeue(); + sw.removeObject(el); + } + if (!sw.getObjectsAt(x, y, SnakeElement.class).isEmpty()) // Kollision mit sich selbst + { + sw.setGameOver(); + return; + } + el = new SnakeElement(); + sw.addObject(el, x, y); + theQueue.enqueue(el); + setLocation(x, y); + } +} diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/SnakeElement.java b/Quellcodes/Alg_DS_Snake/02_snake_loes/SnakeElement.java new file mode 100644 index 0000000..41ebdc1 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/SnakeElement.java @@ -0,0 +1,12 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) + +/** + * Ein Körperelement der Schlange + * + * @author Rainer Helfrich + * @version April 2020 + */ +public class SnakeElement extends Actor +{ + +} diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/SnakeWorld.java b/Quellcodes/Alg_DS_Snake/02_snake_loes/SnakeWorld.java new file mode 100644 index 0000000..e255cbc --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/SnakeWorld.java @@ -0,0 +1,71 @@ +import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo) + +/** + * Die Welt, in der sich die Schlange bewegt + * + * @author Rainer Helfrich + * @version 2020-04-08 + */ +public class SnakeWorld extends World +{ + /** + * Die Ausführungsgeschwindigkeit + */ + private int speed; + + /** + * Erzeugt eine neue Welt + */ + public SnakeWorld() + { + super(30, 20, 20); + } + + /** + * Platziert einen neuen Apfel an einer freien Stelle in der Welt + */ + public void placeApple() + { + Apple a = new Apple(); + int x, y; + do + { + x = Greenfoot.getRandomNumber(getWidth()); + y = Greenfoot.getRandomNumber(getHeight()); + } while (getObjectsAt(x, y, SnakeElement.class).size() > 0); + addObject(a, x, y); + if (speed < 49) // danach nicht mehr spielbar + { + speed++; + Greenfoot.setSpeed(speed); + } + } + + /** + * Wird aufgerufen, wenn das Spiel verloren ist. + * Zeigt eine Nachricht und die Punktezahl an. + */ + public void setGameOver() + { + int points = getObjects(SnakeElement.class).size() - 2; + removeObjects(getObjects(null)); + getBackground().drawImage(new GreenfootImage("Game over", 64, null, null), 170, 130); + getBackground().drawImage(new GreenfootImage("Punkte: " + points, 40, null, null), 220, 220); + } + + /** + * Wartet auf das Drücken der Leertaste, um das Spiel zu initialisieren + */ + public void act() + { + if (Greenfoot.isKeyDown("space") && + getObjects(Snake.class).isEmpty()) + { + setBackground((GreenfootImage)null); + Snake s = new Snake(this); + addObject(s, 15,10); + speed = 22; + placeApple(); + } + } +} diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/images/apple1.png b/Quellcodes/Alg_DS_Snake/02_snake_loes/images/apple1.png new file mode 100644 index 0000000..9b65806 Binary files /dev/null and b/Quellcodes/Alg_DS_Snake/02_snake_loes/images/apple1.png differ diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/images/ball.png b/Quellcodes/Alg_DS_Snake/02_snake_loes/images/ball.png new file mode 100644 index 0000000..3888933 Binary files /dev/null and b/Quellcodes/Alg_DS_Snake/02_snake_loes/images/ball.png differ diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/images/transparent.png b/Quellcodes/Alg_DS_Snake/02_snake_loes/images/transparent.png new file mode 100644 index 0000000..d406af6 Binary files /dev/null and b/Quellcodes/Alg_DS_Snake/02_snake_loes/images/transparent.png differ diff --git a/Quellcodes/Alg_DS_Snake/02_snake_loes/project.greenfoot b/Quellcodes/Alg_DS_Snake/02_snake_loes/project.greenfoot new file mode 100644 index 0000000..afac716 --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/02_snake_loes/project.greenfoot @@ -0,0 +1,96 @@ +#Greenfoot project file +class.Apple.image=apple1.png +class.Snake.image=transparent.png +class.SnakeElement.image=ball.png +dependency1.from=SnakeWorld +dependency1.to=Apple +dependency1.type=UsesDependency +dependency2.from=SnakeWorld +dependency2.to=Snake +dependency2.type=UsesDependency +dependency3.from=SnakeWorld +dependency3.to=SnakeElement +dependency3.type=UsesDependency +dependency4.from=Snake +dependency4.to=Queue +dependency4.type=UsesDependency +dependency5.from=Snake +dependency5.to=SnakeElement +dependency5.type=UsesDependency +dependency6.from=Snake +dependency6.to=ArrayQueue +dependency6.type=UsesDependency +dependency7.from=Snake +dependency7.to=SnakeWorld +dependency7.type=UsesDependency +dependency8.from=Snake +dependency8.to=Apple +dependency8.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +height=795 +package.numDependencies=8 +package.numTargets=6 +project.charset=UTF-8 +publish.hasSource=false +publish.locked=true +publish.longDesc= +publish.shortDesc= +publish.tags= +publish.title= +publish.url= +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +simulation.speed=68 +target1.height=50 +target1.name=ArrayQueue +target1.showInterface=false +target1.type=ClassTarget +target1.width=110 +target1.x=0 +target1.y=0 +target2.height=50 +target2.name=Apple +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=0 +target2.y=0 +target3.height=50 +target3.name=SnakeElement +target3.showInterface=false +target3.type=ClassTarget +target3.width=100 +target3.x=0 +target3.y=0 +target4.height=50 +target4.name=Snake +target4.showInterface=false +target4.type=ClassTarget +target4.width=80 +target4.x=0 +target4.y=0 +target5.height=50 +target5.name=SnakeWorld +target5.showInterface=false +target5.type=ClassTarget +target5.width=90 +target5.x=0 +target5.y=0 +target6.height=50 +target6.name=Queue +target6.showInterface=false +target6.type=AbstractTarget +target6.width=80 +target6.x=0 +target6.y=0 +version=3.0.0 +width=1175 +world.lastInstantiated=SnakeWorld +xPosition=454 +yPosition=62 diff --git a/Quellcodes/Alg_DS_Snake/readme.adoc b/Quellcodes/Alg_DS_Snake/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Snake/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Stack/.gitignore b/Quellcodes/Alg_DS_Stack/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStack.java b/Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStack.java new file mode 100644 index 0000000..8b80577 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStack.java @@ -0,0 +1,48 @@ + +/** + * Ein Stack basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStack extends Stack +{ + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + //# TODO: Hier ist etwas zu tun! + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + //# TODO: Hier ist etwas zu tun! + return null; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + //# TODO: Hier ist etwas zu tun! + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + //# TODO: Hier ist etwas zu tun! + return false; + } +} diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStackTester.java b/Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStackTester.java new file mode 100644 index 0000000..78ce2cc --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStackTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für den ArrayStack + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStackTester extends StackTester +{ + @Before + public void setUp() + { + theStack = new ArrayStack(); + } +} diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStack.java b/Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStack.java new file mode 100644 index 0000000..8140513 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStack.java @@ -0,0 +1,48 @@ + +/** + * Ein Stack basierend auf einer verketteten Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedStack extends Stack +{ + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + //# TODO: Hier ist etwas zu tun! + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + //# TODO: Hier ist etwas zu tun! + return null; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + //# TODO: Hier ist etwas zu tun! + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + //# TODO: Hier ist etwas zu tun! + return false; + } +} diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStackTester.java b/Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStackTester.java new file mode 100644 index 0000000..aae6871 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStackTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für den LinkedStack + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedStackTester extends StackTester +{ + @Before + public void setUp() + { + theStack = new LinkedStack(); + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/README.TXT b/Quellcodes/Alg_DS_Stack/01_stack_roh/README.TXT new file mode 100644 index 0000000..e45dacd --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Stack +PROJEKTZWECK: Zwei Implementationen des ADTs Stack +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Implementieren Sie den ArrayStack oder den LinkedStack. Führen Sie dann bei den entsprechenden Tester-Klassen "Alles testen" aus. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/Stack.java b/Quellcodes/Alg_DS_Stack/01_stack_roh/Stack.java new file mode 100644 index 0000000..332c28a --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/Stack.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Stack +{ + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); +} diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/StackTester.java b/Quellcodes/Alg_DS_Stack/01_stack_roh/StackTester.java new file mode 100644 index 0000000..7833474 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/StackTester.java @@ -0,0 +1,4978 @@ +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Führt eine Reihe von Tests mit einem Stack aus + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class StackTester +{ + /** + * Der zu testende Stack + */ + protected Stack theStack; + + @Test + public void test01() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + theStack.push(9); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(9,theStack.top().intValue()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(5); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(5,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(5,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(9,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(5); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(5,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(5,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(5); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(5,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(5,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(1); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(5); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(5,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(5,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(1,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(3); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(3,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(9); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(9,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(9,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(3,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(1); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(3); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(3,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(3); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(3,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(3,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(1); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(1,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(3,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(3,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(1,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(5); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(5,theStack.top().intValue()); + theStack.push(1); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(3); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(3,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(3,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(1,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(5,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(9); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(9,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(9,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(9); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(9,theStack.top().intValue()); + theStack.push(1); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(1); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(1,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(1,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(1,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(9,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + } + + @Test + public void test02() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(82); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(82,theStack.top().intValue()); + theStack.push(84); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(84,theStack.top().intValue()); + theStack.push(57); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(57,theStack.top().intValue()); + theStack.push(98); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(98,theStack.top().intValue()); + theStack.push(74); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(74,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(74,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(98,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(57,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(84,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(82,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(90); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(90,theStack.top().intValue()); + theStack.push(5); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(5,theStack.top().intValue()); + theStack.push(23); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(23,theStack.top().intValue()); + theStack.push(81); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(81,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(81,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(23,theStack.top().intValue()); + theStack.push(51); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(51,theStack.top().intValue()); + theStack.push(46); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(46,theStack.top().intValue()); + theStack.push(35); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(35,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(35,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(46,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(51,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(23,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(5,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(90,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(51); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(51,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(51,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(5); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(5,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(5,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(94); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(94,theStack.top().intValue()); + theStack.push(20); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(20,theStack.top().intValue()); + theStack.push(58); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(58,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(33); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(33,theStack.top().intValue()); + theStack.push(91); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(91,theStack.top().intValue()); + theStack.push(68); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(68,theStack.top().intValue()); + theStack.push(41); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(41,theStack.top().intValue()); + theStack.push(41); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(41,theStack.top().intValue()); + theStack.push(62); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(62,theStack.top().intValue()); + theStack.push(39); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(39,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(33); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(33,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(33,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(64); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(64,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(64,theStack.top().intValue()); + theStack.push(51); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(51,theStack.top().intValue()); + theStack.push(38); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(38,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(38,theStack.top().intValue()); + theStack.push(12); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(12,theStack.top().intValue()); + theStack.push(46); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(46,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(46,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(12,theStack.top().intValue()); + theStack.push(15); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(15,theStack.top().intValue()); + theStack.push(98); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(98,theStack.top().intValue()); + theStack.push(65); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(65,theStack.top().intValue()); + theStack.push(92); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(92,theStack.top().intValue()); + theStack.push(40); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(40,theStack.top().intValue()); + theStack.push(40); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(40,theStack.top().intValue()); + theStack.push(30); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(30,theStack.top().intValue()); + theStack.push(42); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(42,theStack.top().intValue()); + theStack.push(12); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(12,theStack.top().intValue()); + theStack.push(81); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(81,theStack.top().intValue()); + theStack.push(55); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(55,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(55,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(81,theStack.top().intValue()); + theStack.push(21); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(21,theStack.top().intValue()); + theStack.push(17); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(17,theStack.top().intValue()); + theStack.push(62); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(62,theStack.top().intValue()); + theStack.push(21); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(21,theStack.top().intValue()); + theStack.push(59); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(59,theStack.top().intValue()); + theStack.push(18); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(18,theStack.top().intValue()); + theStack.push(7); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(7,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(7,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(18,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(59,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(21,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(62,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(17,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(21,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(81,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(12,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(42,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(30,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(40,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(40,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(92,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(65,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(98,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(15,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(12,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(38,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(51,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(64,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(39,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(62,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(41,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(41,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(68,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(91,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(33,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(58,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(20,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(94,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(50); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(50,theStack.top().intValue()); + theStack.push(27); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(27,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(27,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(50,theStack.top().intValue()); + theStack.push(89); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(89,theStack.top().intValue()); + theStack.push(82); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(82,theStack.top().intValue()); + theStack.push(30); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(30,theStack.top().intValue()); + theStack.push(24); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(24,theStack.top().intValue()); + theStack.push(62); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(62,theStack.top().intValue()); + theStack.push(24); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(24,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(24,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(62,theStack.top().intValue()); + theStack.push(32); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(32,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(32,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(62,theStack.top().intValue()); + theStack.push(57); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(57,theStack.top().intValue()); + theStack.push(39); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(39,theStack.top().intValue()); + theStack.push(90); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(90,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(90,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(39,theStack.top().intValue()); + theStack.push(82); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(82,theStack.top().intValue()); + theStack.push(42); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(42,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(42,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(82,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(39,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(57,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(62,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(24,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(30,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(82,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(89,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(50,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(81); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(81,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(81,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(30); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(30,theStack.top().intValue()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + theStack.push(93); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(93,theStack.top().intValue()); + theStack.push(64); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(64,theStack.top().intValue()); + theStack.push(40); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(40,theStack.top().intValue()); + theStack.push(85); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(85,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(85,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(40,theStack.top().intValue()); + theStack.push(24); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(24,theStack.top().intValue()); + theStack.push(91); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(91,theStack.top().intValue()); + } + + @Test + public void test03() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(94); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(94,theStack.top().intValue()); + theStack.push(424); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(424,theStack.top().intValue()); + theStack.push(550); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(550,theStack.top().intValue()); + theStack.push(301); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(301,theStack.top().intValue()); + theStack.push(57); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(57,theStack.top().intValue()); + theStack.push(188); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(188,theStack.top().intValue()); + theStack.push(784); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(784,theStack.top().intValue()); + theStack.push(235); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(235,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(235,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(784,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(188,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(57,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(301,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(550,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(424,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(94,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(96); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(96,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(96,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(807); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(807,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(807,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(0); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(0,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(0,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(801); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(801,theStack.top().intValue()); + theStack.push(683); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(683,theStack.top().intValue()); + theStack.push(819); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(819,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(819,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(683,theStack.top().intValue()); + theStack.push(516); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(516,theStack.top().intValue()); + theStack.push(940); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(940,theStack.top().intValue()); + theStack.push(757); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(757,theStack.top().intValue()); + theStack.push(828); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(828,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(828,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(757,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(940,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(516,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(683,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(801,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(737); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(737,theStack.top().intValue()); + theStack.push(883); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(883,theStack.top().intValue()); + theStack.push(264); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(264,theStack.top().intValue()); + theStack.push(165); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(165,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(165,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(264,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(883,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(737,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(482); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(482,theStack.top().intValue()); + theStack.push(128); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(128,theStack.top().intValue()); + theStack.push(665); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(665,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(665,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(128,theStack.top().intValue()); + theStack.push(747); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(747,theStack.top().intValue()); + theStack.push(348); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(348,theStack.top().intValue()); + theStack.push(182); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(182,theStack.top().intValue()); + theStack.push(242); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(242,theStack.top().intValue()); + theStack.push(805); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(805,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(805,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(242,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(182,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(348,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(747,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(128,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(482,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(202); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(202,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(202,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(384); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(384,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(384,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(870); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(870,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(870,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(827); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(827,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(827,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(763); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(763,theStack.top().intValue()); + theStack.push(794); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(794,theStack.top().intValue()); + theStack.push(865); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(865,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(865,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(794,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(763,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(135); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(135,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(135,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(971); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(971,theStack.top().intValue()); + theStack.push(769); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(769,theStack.top().intValue()); + theStack.push(561); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(561,theStack.top().intValue()); + theStack.push(562); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(562,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(562,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(561,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(561,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(769,theStack.top().intValue()); + theStack.push(244); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(244,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(244,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(769,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(769,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(971,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(23); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(23,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(23,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(466); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(466,theStack.top().intValue()); + theStack.push(756); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(756,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(756,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(466,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(26); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(26,theStack.top().intValue()); + theStack.push(446); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(446,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(446,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(26,theStack.top().intValue()); + theStack.push(979); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(979,theStack.top().intValue()); + theStack.push(710); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(710,theStack.top().intValue()); + theStack.push(113); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(113,theStack.top().intValue()); + theStack.push(112); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(112,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(112,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(113,theStack.top().intValue()); + theStack.push(755); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(755,theStack.top().intValue()); + theStack.push(430); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(430,theStack.top().intValue()); + theStack.push(848); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(848,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(848,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(430,theStack.top().intValue()); + theStack.push(627); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(627,theStack.top().intValue()); + theStack.push(984); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(984,theStack.top().intValue()); + theStack.push(980); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(980,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(980,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(984,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(627,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(430,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(755,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(113,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(710,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(979,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(26,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(952); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(952,theStack.top().intValue()); + theStack.push(403); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(403,theStack.top().intValue()); + theStack.push(522); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(522,theStack.top().intValue()); + theStack.push(765); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(765,theStack.top().intValue()); + theStack.push(251); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(251,theStack.top().intValue()); + theStack.push(313); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(313,theStack.top().intValue()); + theStack.push(481); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(481,theStack.top().intValue()); + theStack.push(875); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(875,theStack.top().intValue()); + theStack.push(672); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(672,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(672,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(875,theStack.top().intValue()); + theStack.push(214); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(214,theStack.top().intValue()); + theStack.push(480); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(480,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(480,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(214,theStack.top().intValue()); + } + + @Test + public void test04() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(757); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(757,theStack.top().intValue()); + theStack.push(190); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(190,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(190,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(757,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(805); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(805,theStack.top().intValue()); + theStack.push(975); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(975,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(975,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(805,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(859); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(859,theStack.top().intValue()); + theStack.push(84); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(84,theStack.top().intValue()); + theStack.push(790); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(790,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(790,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(84,theStack.top().intValue()); + theStack.push(464); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(464,theStack.top().intValue()); + theStack.push(127); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(127,theStack.top().intValue()); + theStack.push(800); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(800,theStack.top().intValue()); + theStack.push(108); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(108,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(108,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(800,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(127,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(464,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(84,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(859,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(586); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(586,theStack.top().intValue()); + theStack.push(463); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(463,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(463,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(586,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(586,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(515); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(515,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(515,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(555); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(555,theStack.top().intValue()); + theStack.push(278); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(278,theStack.top().intValue()); + theStack.push(729); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(729,theStack.top().intValue()); + theStack.push(36); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(36,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(36,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(729,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(278,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(555,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(81); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(81,theStack.top().intValue()); + theStack.push(176); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(176,theStack.top().intValue()); + theStack.push(124); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(124,theStack.top().intValue()); + theStack.push(533); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(533,theStack.top().intValue()); + theStack.push(361); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(361,theStack.top().intValue()); + theStack.push(868); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(868,theStack.top().intValue()); + theStack.push(296); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(296,theStack.top().intValue()); + theStack.push(914); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(914,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(914,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(296,theStack.top().intValue()); + theStack.push(683); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(683,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(683,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(296,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(296,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(868,theStack.top().intValue()); + theStack.push(576); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(576,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(576,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(868,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(868,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(361,theStack.top().intValue()); + theStack.push(63); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(63,theStack.top().intValue()); + theStack.push(514); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(514,theStack.top().intValue()); + theStack.push(162); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(162,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(162,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(514,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(514,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(63,theStack.top().intValue()); + theStack.push(431); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(431,theStack.top().intValue()); + theStack.push(941); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(941,theStack.top().intValue()); + theStack.push(471); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(471,theStack.top().intValue()); + theStack.push(712); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(712,theStack.top().intValue()); + theStack.push(571); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(571,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(571,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(712,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(712,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(471,theStack.top().intValue()); + theStack.push(113); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(113,theStack.top().intValue()); + theStack.push(143); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(143,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(143,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(113,theStack.top().intValue()); + theStack.push(803); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(803,theStack.top().intValue()); + theStack.push(390); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(390,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(390,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(803,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(113,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(471,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(941,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(431,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(63,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(361,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(533,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(124,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(176,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(81,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(48); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(48,theStack.top().intValue()); + theStack.push(759); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(759,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(759,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(48,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(48,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(385); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(385,theStack.top().intValue()); + theStack.push(193); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(193,theStack.top().intValue()); + theStack.push(57); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(57,theStack.top().intValue()); + theStack.push(183); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(183,theStack.top().intValue()); + theStack.push(476); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(476,theStack.top().intValue()); + theStack.push(897); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(897,theStack.top().intValue()); + theStack.push(936); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(936,theStack.top().intValue()); + theStack.push(593); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(593,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(593,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(936,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(936,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(897,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(476,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(183,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(57,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(193,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(385,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(685); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(685,theStack.top().intValue()); + theStack.push(952); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(952,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(952,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(685,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(685,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(257); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(257,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(257,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(297); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(297,theStack.top().intValue()); + theStack.push(180); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(180,theStack.top().intValue()); + theStack.push(409); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(409,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(409,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(180,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(180,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(297,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(809); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(809,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(809,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(845); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(845,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(845,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(481); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(481,theStack.top().intValue()); + theStack.push(697); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(697,theStack.top().intValue()); + theStack.push(654); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(654,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(654,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(697,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(697,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(481,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(62); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(62,theStack.top().intValue()); + theStack.push(980); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(980,theStack.top().intValue()); + theStack.push(466); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(466,theStack.top().intValue()); + theStack.push(922); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(922,theStack.top().intValue()); + theStack.push(445); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(445,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(445,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(922,theStack.top().intValue()); + } + + @Test + public void test05() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(98); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(98,theStack.top().intValue()); + theStack.push(30); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(30,theStack.top().intValue()); + theStack.push(963); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(963,theStack.top().intValue()); + theStack.push(454); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(454,theStack.top().intValue()); + theStack.push(77); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(77,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(77,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(454,theStack.top().intValue()); + theStack.push(24); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(24,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(24,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(454,theStack.top().intValue()); + theStack.push(622); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(622,theStack.top().intValue()); + theStack.push(748); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(748,theStack.top().intValue()); + theStack.push(584); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(584,theStack.top().intValue()); + theStack.push(528); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(528,theStack.top().intValue()); + theStack.push(547); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(547,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(547,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(528,theStack.top().intValue()); + theStack.push(440); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(440,theStack.top().intValue()); + theStack.push(485); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(485,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(485,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(440,theStack.top().intValue()); + theStack.push(549); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(549,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(549,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(440,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(528,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(584,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(748,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(622,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(454,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(963,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(30,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(98,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(845); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(845,theStack.top().intValue()); + theStack.push(834); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(834,theStack.top().intValue()); + theStack.push(920); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(920,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(920,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(834,theStack.top().intValue()); + theStack.push(334); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(334,theStack.top().intValue()); + theStack.push(528); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(528,theStack.top().intValue()); + theStack.push(44); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(44,theStack.top().intValue()); + theStack.push(778); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(778,theStack.top().intValue()); + theStack.push(499); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(499,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(499,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(778,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(44,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(528,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(334,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(834,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(845,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(657); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(657,theStack.top().intValue()); + theStack.push(588); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(588,theStack.top().intValue()); + theStack.push(82); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(82,theStack.top().intValue()); + theStack.push(213); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(213,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(213,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(82,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(82,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(588,theStack.top().intValue()); + theStack.push(78); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(78,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(78,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(588,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(588,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(657,theStack.top().intValue()); + theStack.push(614); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(614,theStack.top().intValue()); + theStack.push(3); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(3,theStack.top().intValue()); + theStack.push(848); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(848,theStack.top().intValue()); + theStack.push(691); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(691,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(691,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(848,theStack.top().intValue()); + theStack.push(468); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(468,theStack.top().intValue()); + theStack.push(393); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(393,theStack.top().intValue()); + theStack.push(294); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(294,theStack.top().intValue()); + theStack.push(329); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(329,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(329,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(294,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(393,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(468,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(848,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(3,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(614,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(657,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(665); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(665,theStack.top().intValue()); + theStack.push(771); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(771,theStack.top().intValue()); + theStack.push(442); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(442,theStack.top().intValue()); + theStack.push(405); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(405,theStack.top().intValue()); + theStack.push(930); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(930,theStack.top().intValue()); + theStack.push(513); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(513,theStack.top().intValue()); + theStack.push(289); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(289,theStack.top().intValue()); + theStack.push(455); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(455,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(455,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(289,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(513,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(930,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(405,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(442,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(771,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(665,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(791); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(791,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(791,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(362); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(362,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(362,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(720); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(720,theStack.top().intValue()); + theStack.push(328); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(328,theStack.top().intValue()); + theStack.push(454); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(454,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(454,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(328,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(720,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(626); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(626,theStack.top().intValue()); + theStack.push(878); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(878,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(878,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(626,theStack.top().intValue()); + theStack.push(220); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(220,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(220,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(626,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(626,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(959); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(959,theStack.top().intValue()); + theStack.push(907); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(907,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(907,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(959,theStack.top().intValue()); + theStack.push(942); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(942,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(942,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(959,theStack.top().intValue()); + theStack.push(971); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(971,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(971,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(959,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(959,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(781); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(781,theStack.top().intValue()); + theStack.push(288); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(288,theStack.top().intValue()); + theStack.push(677); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(677,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(677,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(288,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(288,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(781,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(295); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(295,theStack.top().intValue()); + theStack.push(684); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(684,theStack.top().intValue()); + theStack.push(976); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(976,theStack.top().intValue()); + theStack.push(570); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(570,theStack.top().intValue()); + theStack.push(873); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(873,theStack.top().intValue()); + theStack.push(965); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(965,theStack.top().intValue()); + theStack.push(241); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(241,theStack.top().intValue()); + theStack.push(573); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(573,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(573,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(241,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(241,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(965,theStack.top().intValue()); + theStack.push(645); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(645,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(645,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(965,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(873,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(570,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(976,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(684,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(295,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(109); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(109,theStack.top().intValue()); + } + + @Test + public void test06() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(781); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(781,theStack.top().intValue()); + theStack.push(122); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(122,theStack.top().intValue()); + theStack.push(687); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(687,theStack.top().intValue()); + theStack.push(131); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(131,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(131,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(687,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(122,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(781,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(677); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(677,theStack.top().intValue()); + theStack.push(537); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(537,theStack.top().intValue()); + theStack.push(585); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(585,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(585,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(537,theStack.top().intValue()); + theStack.push(922); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(922,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(922,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(537,theStack.top().intValue()); + theStack.push(308); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(308,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(308,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(537,theStack.top().intValue()); + theStack.push(32); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(32,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(32,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(537,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(677,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(359); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(359,theStack.top().intValue()); + theStack.push(19); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(19,theStack.top().intValue()); + theStack.push(251); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(251,theStack.top().intValue()); + theStack.push(564); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(564,theStack.top().intValue()); + theStack.push(996); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(996,theStack.top().intValue()); + theStack.push(317); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(317,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(317,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(996,theStack.top().intValue()); + theStack.push(471); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(471,theStack.top().intValue()); + theStack.push(399); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(399,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(399,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(471,theStack.top().intValue()); + theStack.push(999); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(999,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(999,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(471,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(996,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(564,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(251,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(19,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(359,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(587); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(587,theStack.top().intValue()); + theStack.push(428); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(428,theStack.top().intValue()); + theStack.push(762); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(762,theStack.top().intValue()); + theStack.push(836); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(836,theStack.top().intValue()); + theStack.push(379); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(379,theStack.top().intValue()); + theStack.push(408); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(408,theStack.top().intValue()); + theStack.push(156); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(156,theStack.top().intValue()); + theStack.push(451); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(451,theStack.top().intValue()); + theStack.push(741); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(741,theStack.top().intValue()); + theStack.push(520); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(520,theStack.top().intValue()); + theStack.push(315); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(315,theStack.top().intValue()); + theStack.push(309); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(309,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(309,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(315,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(315,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(520,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(741,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(451,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(156,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(408,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(379,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(836,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(762,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(428,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(587,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(546); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(546,theStack.top().intValue()); + theStack.push(836); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(836,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(836,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(546,theStack.top().intValue()); + theStack.push(837); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(837,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(837,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(546,theStack.top().intValue()); + theStack.push(939); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(939,theStack.top().intValue()); + theStack.push(214); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(214,theStack.top().intValue()); + theStack.push(284); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(284,theStack.top().intValue()); + theStack.push(994); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(994,theStack.top().intValue()); + theStack.push(132); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(132,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(132,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(994,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(284,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(214,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(939,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(546,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(339); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(339,theStack.top().intValue()); + theStack.push(312); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(312,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(312,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(339,theStack.top().intValue()); + theStack.push(663); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(663,theStack.top().intValue()); + theStack.push(800); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(800,theStack.top().intValue()); + theStack.push(36); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(36,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(36,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(800,theStack.top().intValue()); + theStack.push(565); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(565,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(565,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(800,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(663,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(339,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(65); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(65,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(65,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(653); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(653,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(653,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(496); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(496,theStack.top().intValue()); + theStack.push(738); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(738,theStack.top().intValue()); + theStack.push(385); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(385,theStack.top().intValue()); + theStack.push(792); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(792,theStack.top().intValue()); + theStack.push(33); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(33,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(33,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(792,theStack.top().intValue()); + theStack.push(976); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(976,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(976,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(792,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(385,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(738,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(496,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(405); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(405,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(405,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(974); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(974,theStack.top().intValue()); + theStack.push(920); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(920,theStack.top().intValue()); + theStack.push(815); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(815,theStack.top().intValue()); + theStack.push(737); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(737,theStack.top().intValue()); + theStack.push(531); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(531,theStack.top().intValue()); + theStack.push(279); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(279,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(279,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(531,theStack.top().intValue()); + theStack.push(970); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(970,theStack.top().intValue()); + theStack.push(415); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(415,theStack.top().intValue()); + theStack.push(884); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(884,theStack.top().intValue()); + theStack.push(703); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(703,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(703,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(884,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(884,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(415,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(970,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(531,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(737,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(815,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(920,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(974,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(976); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(976,theStack.top().intValue()); + theStack.push(333); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(333,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(333,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(976,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(955); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(955,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(955,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(68); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(68,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(68,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(701); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(701,theStack.top().intValue()); + theStack.push(258); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(258,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(258,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(701,theStack.top().intValue()); + } + + @Test + public void test07() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(456); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(456,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(456,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(983); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(983,theStack.top().intValue()); + theStack.push(134); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(134,theStack.top().intValue()); + theStack.push(639); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(639,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(639,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(134,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(134,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(983,theStack.top().intValue()); + theStack.push(721); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(721,theStack.top().intValue()); + theStack.push(219); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(219,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(219,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(721,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(721,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(983,theStack.top().intValue()); + theStack.push(425); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(425,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(425,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(983,theStack.top().intValue()); + theStack.push(196); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(196,theStack.top().intValue()); + theStack.push(720); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(720,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(720,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(196,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(983,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(741); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(741,theStack.top().intValue()); + theStack.push(731); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(731,theStack.top().intValue()); + theStack.push(697); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(697,theStack.top().intValue()); + theStack.push(519); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(519,theStack.top().intValue()); + theStack.push(188); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(188,theStack.top().intValue()); + theStack.push(943); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(943,theStack.top().intValue()); + theStack.push(267); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(267,theStack.top().intValue()); + theStack.push(467); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(467,theStack.top().intValue()); + theStack.push(845); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(845,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(845,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(467,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(467,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(267,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(943,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(188,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(519,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(697,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(731,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(741,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(489); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(489,theStack.top().intValue()); + theStack.push(801); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(801,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(801,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(489,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(489,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(591); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(591,theStack.top().intValue()); + theStack.push(439); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(439,theStack.top().intValue()); + theStack.push(195); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(195,theStack.top().intValue()); + theStack.push(937); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(937,theStack.top().intValue()); + theStack.push(575); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(575,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(575,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(937,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(195,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(439,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(591,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(250); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(250,theStack.top().intValue()); + theStack.push(505); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(505,theStack.top().intValue()); + theStack.push(459); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(459,theStack.top().intValue()); + theStack.push(269); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(269,theStack.top().intValue()); + theStack.push(158); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(158,theStack.top().intValue()); + theStack.push(744); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(744,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(744,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(158,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(269,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(459,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(505,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(250,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(483); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(483,theStack.top().intValue()); + theStack.push(168); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(168,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(168,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(483,theStack.top().intValue()); + theStack.push(22); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(22,theStack.top().intValue()); + theStack.push(259); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(259,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(259,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(22,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(22,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(483,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(84); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(84,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(84,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(864); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(864,theStack.top().intValue()); + theStack.push(689); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(689,theStack.top().intValue()); + theStack.push(235); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(235,theStack.top().intValue()); + theStack.push(235); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(235,theStack.top().intValue()); + theStack.push(974); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(974,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(974,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(235,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(235,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(689,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(864,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(959); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(959,theStack.top().intValue()); + theStack.push(901); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(901,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(901,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(959,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(337); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(337,theStack.top().intValue()); + theStack.push(980); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(980,theStack.top().intValue()); + theStack.push(527); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(527,theStack.top().intValue()); + theStack.push(781); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(781,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(781,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(527,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(980,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(337,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(265); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(265,theStack.top().intValue()); + theStack.push(182); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(182,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(182,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(265,theStack.top().intValue()); + theStack.push(305); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(305,theStack.top().intValue()); + theStack.push(640); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(640,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(640,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(305,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(305,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(265,theStack.top().intValue()); + theStack.push(861); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(861,theStack.top().intValue()); + theStack.push(226); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(226,theStack.top().intValue()); + theStack.push(974); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(974,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(974,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(226,theStack.top().intValue()); + theStack.push(56); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(56,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(56,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(226,theStack.top().intValue()); + theStack.push(973); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(973,theStack.top().intValue()); + theStack.push(492); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(492,theStack.top().intValue()); + theStack.push(333); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(333,theStack.top().intValue()); + theStack.push(466); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(466,theStack.top().intValue()); + theStack.push(575); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(575,theStack.top().intValue()); + theStack.push(613); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(613,theStack.top().intValue()); + theStack.push(357); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(357,theStack.top().intValue()); + theStack.push(365); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(365,theStack.top().intValue()); + theStack.push(166); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(166,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(166,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(365,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(357,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(613,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(575,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(466,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(333,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(492,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(973,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(226,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(861,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(265,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(625); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(625,theStack.top().intValue()); + theStack.push(253); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(253,theStack.top().intValue()); + theStack.push(92); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(92,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(92,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(253,theStack.top().intValue()); + theStack.push(778); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(778,theStack.top().intValue()); + theStack.push(901); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(901,theStack.top().intValue()); + theStack.push(962); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(962,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(962,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(901,theStack.top().intValue()); + } + + @Test + public void test08() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(772); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(772,theStack.top().intValue()); + theStack.push(44); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(44,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(44,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(772,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(983); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(983,theStack.top().intValue()); + theStack.push(771); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(771,theStack.top().intValue()); + theStack.push(932); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(932,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(932,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(771,theStack.top().intValue()); + theStack.push(39); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(39,theStack.top().intValue()); + theStack.push(724); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(724,theStack.top().intValue()); + theStack.push(917); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(917,theStack.top().intValue()); + theStack.push(362); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(362,theStack.top().intValue()); + theStack.push(70); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(70,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(70,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(362,theStack.top().intValue()); + theStack.push(584); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(584,theStack.top().intValue()); + theStack.push(672); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(672,theStack.top().intValue()); + theStack.push(2); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(2,theStack.top().intValue()); + theStack.push(679); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(679,theStack.top().intValue()); + theStack.push(873); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(873,theStack.top().intValue()); + theStack.push(336); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(336,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(336,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(873,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(873,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(679,theStack.top().intValue()); + theStack.push(823); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(823,theStack.top().intValue()); + theStack.push(462); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(462,theStack.top().intValue()); + theStack.push(274); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(274,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(274,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(462,theStack.top().intValue()); + theStack.push(626); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(626,theStack.top().intValue()); + theStack.push(639); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(639,theStack.top().intValue()); + theStack.push(75); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(75,theStack.top().intValue()); + theStack.push(542); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(542,theStack.top().intValue()); + theStack.push(397); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(397,theStack.top().intValue()); + theStack.push(189); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(189,theStack.top().intValue()); + theStack.push(384); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(384,theStack.top().intValue()); + theStack.push(874); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(874,theStack.top().intValue()); + theStack.push(865); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(865,theStack.top().intValue()); + theStack.push(728); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(728,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(728,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(865,theStack.top().intValue()); + theStack.push(975); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(975,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(975,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(865,theStack.top().intValue()); + theStack.push(871); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(871,theStack.top().intValue()); + theStack.push(613); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(613,theStack.top().intValue()); + theStack.push(71); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(71,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(71,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(613,theStack.top().intValue()); + theStack.push(734); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(734,theStack.top().intValue()); + theStack.push(64); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(64,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(64,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(734,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(613,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(871,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(865,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(874,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(384,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(189,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(397,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(542,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(75,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(639,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(626,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(462,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(823,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(679,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(2,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(672,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(584,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(362,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(917,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(724,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(39,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(771,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(983,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(392); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(392,theStack.top().intValue()); + theStack.push(906); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(906,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(906,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(392,theStack.top().intValue()); + theStack.push(734); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(734,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(734,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(392,theStack.top().intValue()); + theStack.push(560); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(560,theStack.top().intValue()); + theStack.push(853); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(853,theStack.top().intValue()); + theStack.push(283); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(283,theStack.top().intValue()); + theStack.push(948); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(948,theStack.top().intValue()); + theStack.push(364); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(364,theStack.top().intValue()); + theStack.push(825); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(825,theStack.top().intValue()); + theStack.push(80); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(80,theStack.top().intValue()); + theStack.push(886); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(886,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(886,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(80,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(80,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(825,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(364,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(948,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(283,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(853,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(560,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(392,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(405); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(405,theStack.top().intValue()); + theStack.push(996); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(996,theStack.top().intValue()); + theStack.push(198); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(198,theStack.top().intValue()); + theStack.push(926); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(926,theStack.top().intValue()); + theStack.push(681); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(681,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(681,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(926,theStack.top().intValue()); + theStack.push(893); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(893,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(893,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(926,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(198,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(996,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(405,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(225); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(225,theStack.top().intValue()); + theStack.push(540); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(540,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(540,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(225,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(286); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(286,theStack.top().intValue()); + theStack.push(289); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(289,theStack.top().intValue()); + theStack.push(142); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(142,theStack.top().intValue()); + theStack.push(225); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(225,theStack.top().intValue()); + theStack.push(124); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(124,theStack.top().intValue()); + theStack.push(662); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(662,theStack.top().intValue()); + theStack.push(389); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(389,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(389,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(662,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(662,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(124,theStack.top().intValue()); + theStack.push(950); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(950,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(950,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(124,theStack.top().intValue()); + theStack.push(392); + + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(392,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(392,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(124,theStack.top().intValue()); + theStack.push(309); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(309,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(309,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(124,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(124,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(225,theStack.top().intValue()); + theStack.push(550); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(550,theStack.top().intValue()); + theStack.push(760); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(760,theStack.top().intValue()); + theStack.push(585); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(585,theStack.top().intValue()); + theStack.push(132); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(132,theStack.top().intValue()); + theStack.push(207); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(207,theStack.top().intValue()); + theStack.push(716); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(716,theStack.top().intValue()); + theStack.push(805); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(805,theStack.top().intValue()); + theStack.push(274); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(274,theStack.top().intValue()); + theStack.push(144); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(144,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(144,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(274,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(805,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(716,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(207,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(132,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(585,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(760,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(550,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(225,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(142,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(289,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(286,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(99); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(99,theStack.top().intValue()); + theStack.push(404); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(404,theStack.top().intValue()); + } + + @Test + public void test09() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(858); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(858,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(858,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(139); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(139,theStack.top().intValue()); + theStack.push(954); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(954,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(954,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(139,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(861); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(861,theStack.top().intValue()); + theStack.push(879); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(879,theStack.top().intValue()); + theStack.push(757); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(757,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(757,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(879,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(879,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(861,theStack.top().intValue()); + theStack.push(290); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(290,theStack.top().intValue()); + theStack.push(288); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(288,theStack.top().intValue()); + theStack.push(200); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(200,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(200,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(288,theStack.top().intValue()); + theStack.push(155); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(155,theStack.top().intValue()); + theStack.push(989); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(989,theStack.top().intValue()); + theStack.push(362); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(362,theStack.top().intValue()); + theStack.push(62); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(62,theStack.top().intValue()); + theStack.push(716); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(716,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(716,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(62,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(362,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(989,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(155,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(288,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(290,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(861,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(152); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(152,theStack.top().intValue()); + theStack.push(503); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(503,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(503,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(152,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(386); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(386,theStack.top().intValue()); + theStack.push(487); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(487,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(487,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(386,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(386,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(256); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(256,theStack.top().intValue()); + theStack.push(135); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(135,theStack.top().intValue()); + theStack.push(260); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(260,theStack.top().intValue()); + theStack.push(625); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(625,theStack.top().intValue()); + theStack.push(356); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(356,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(356,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(625,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(260,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(135,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(256,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(628); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(628,theStack.top().intValue()); + theStack.push(522); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(522,theStack.top().intValue()); + theStack.push(177); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(177,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(177,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(522,theStack.top().intValue()); + theStack.push(55); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(55,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(55,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(522,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(522,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(628,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(46); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(46,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(46,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(400); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(400,theStack.top().intValue()); + theStack.push(876); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(876,theStack.top().intValue()); + theStack.push(417); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(417,theStack.top().intValue()); + theStack.push(725); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(725,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(725,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(417,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(417,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(876,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(876,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(400,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(400,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(329); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(329,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(329,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(681); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(681,theStack.top().intValue()); + theStack.push(231); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(231,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(231,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(681,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(99); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(99,theStack.top().intValue()); + theStack.push(894); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(894,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(894,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(99,theStack.top().intValue()); + theStack.push(948); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(948,theStack.top().intValue()); + theStack.push(313); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(313,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(313,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(948,theStack.top().intValue()); + theStack.push(811); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(811,theStack.top().intValue()); + theStack.push(102); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(102,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(102,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(811,theStack.top().intValue()); + theStack.push(290); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(290,theStack.top().intValue()); + theStack.push(258); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(258,theStack.top().intValue()); + theStack.push(323); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(323,theStack.top().intValue()); + theStack.push(610); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(610,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(610,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(323,theStack.top().intValue()); + theStack.push(976); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(976,theStack.top().intValue()); + theStack.push(140); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(140,theStack.top().intValue()); + theStack.push(169); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(169,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(169,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(140,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(140,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(976,theStack.top().intValue()); + theStack.push(281); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(281,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(281,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(976,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(976,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(323,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(323,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(258,theStack.top().intValue()); + theStack.push(577); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(577,theStack.top().intValue()); + theStack.push(642); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(642,theStack.top().intValue()); + theStack.push(407); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(407,theStack.top().intValue()); + theStack.push(787); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(787,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(787,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(407,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(642,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(577,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(258,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(290,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(811,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(948,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(99,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(72); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(72,theStack.top().intValue()); + theStack.push(651); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(651,theStack.top().intValue()); + theStack.push(603); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(603,theStack.top().intValue()); + theStack.push(566); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(566,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(566,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(603,theStack.top().intValue()); + theStack.push(572); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(572,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(572,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(603,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(651,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(72,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(725); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(725,theStack.top().intValue()); + theStack.push(931); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(931,theStack.top().intValue()); + theStack.push(359); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(359,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(359,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(931,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(725,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(610); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(610,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(610,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + } + + @Test + public void test10() + { + Integer tmp; + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(963); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(963,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(963,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(179); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(179,theStack.top().intValue()); + theStack.push(479); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(479,theStack.top().intValue()); + theStack.push(88); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(88,theStack.top().intValue()); + theStack.push(602); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(602,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(602,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(88,theStack.top().intValue()); + theStack.push(29); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(29,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(29,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(88,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(479,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(179,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(217); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(217,theStack.top().intValue()); + theStack.push(345); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(345,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(345,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(217,theStack.top().intValue()); + theStack.push(836); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(836,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(836,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(217,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(299); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(299,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(299,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(791); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(791,theStack.top().intValue()); + theStack.push(684); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(684,theStack.top().intValue()); + theStack.push(516); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(516,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(516,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(684,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(684,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(791,theStack.top().intValue()); + theStack.push(898); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(898,theStack.top().intValue()); + theStack.push(6); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(6,theStack.top().intValue()); + theStack.push(742); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(742,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(742,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(6,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(898,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(791,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(326); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(326,theStack.top().intValue()); + theStack.push(557); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(557,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(557,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(326,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(79); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(79,theStack.top().intValue()); + theStack.push(604); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(604,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(604,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(79,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(776); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(776,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(776,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(495); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(495,theStack.top().intValue()); + theStack.push(963); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(963,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(963,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(495,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(4); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + theStack.push(408); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(408,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(408,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(4,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(4,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(42); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(42,theStack.top().intValue()); + theStack.push(839); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(839,theStack.top().intValue()); + theStack.push(125); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(125,theStack.top().intValue()); + theStack.push(435); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(435,theStack.top().intValue()); + theStack.push(594); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(594,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(594,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(435,theStack.top().intValue()); + theStack.push(502); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(502,theStack.top().intValue()); + theStack.push(397); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(397,theStack.top().intValue()); + theStack.push(316); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(316,theStack.top().intValue()); + theStack.push(17); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(17,theStack.top().intValue()); + theStack.push(141); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(141,theStack.top().intValue()); + theStack.push(611); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(611,theStack.top().intValue()); + theStack.push(909); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(909,theStack.top().intValue()); + theStack.push(47); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(47,theStack.top().intValue()); + theStack.push(973); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(973,theStack.top().intValue()); + theStack.push(122); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(122,theStack.top().intValue()); + theStack.push(426); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(426,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(426,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(122,theStack.top().intValue()); + theStack.push(485); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(485,theStack.top().intValue()); + theStack.push(446); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(446,theStack.top().intValue()); + theStack.push(196); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(196,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(196,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(446,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(485,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(122,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(973,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(47,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(909,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(611,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(141,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(17,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(316,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(397,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(502,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(435,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(125,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(839,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(42,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(248); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(248,theStack.top().intValue()); + theStack.push(895); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(895,theStack.top().intValue()); + theStack.push(625); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(625,theStack.top().intValue()); + theStack.push(103); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(103,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(103,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(625,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(895,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(248,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(873); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(873,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(873,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(457); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(457,theStack.top().intValue()); + theStack.push(8); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(8,theStack.top().intValue()); + theStack.push(859); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(859,theStack.top().intValue()); + theStack.push(464); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(464,theStack.top().intValue()); + theStack.push(532); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(532,theStack.top().intValue()); + theStack.push(377); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(377,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(377,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(532,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(464,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(859,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(8,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(457,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(428); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(428,theStack.top().intValue()); + theStack.push(455); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(455,theStack.top().intValue()); + theStack.push(884); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(884,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(884,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(455,theStack.top().intValue()); + theStack.push(871); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(871,theStack.top().intValue()); + theStack.push(605); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(605,theStack.top().intValue()); + theStack.push(237); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(237,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(237,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(605,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(605,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(871,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(455,tmp.intValue()); + tmp = theStack.pop(); + assertEquals(428,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(507); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(507,theStack.top().intValue()); + theStack.push(809); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(809,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(809,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(507,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(507,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(592); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(592,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(592,tmp.intValue()); + assertTrue(theStack.isEmpty()); + assertNull(theStack.top()); + theStack.push(307); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(307,theStack.top().intValue()); + theStack.push(711); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(711,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(711,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(307,theStack.top().intValue()); + theStack.push(531); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(531,theStack.top().intValue()); + theStack.push(918); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(918,theStack.top().intValue()); + theStack.push(561); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(561,theStack.top().intValue()); + tmp = theStack.pop(); + assertEquals(561,tmp.intValue()); + assertFalse(theStack.isEmpty()); + assertNotNull(theStack.top()); + assertEquals(918,theStack.top().intValue()); + } +} diff --git a/Quellcodes/Alg_DS_Stack/01_stack_roh/package.bluej b/Quellcodes/Alg_DS_Stack/01_stack_roh/package.bluej new file mode 100644 index 0000000..59130a3 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/01_stack_roh/package.bluej @@ -0,0 +1,76 @@ +#BlueJ package file +dependency1.from=StackTester +dependency1.to=Stack +dependency1.type=UsesDependency +dependency2.from=LinkedStackTester +dependency2.to=LinkedStack +dependency2.type=UsesDependency +dependency3.from=ArrayStackTester +dependency3.to=ArrayStack +dependency3.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=816 +editor.fx.0.x=59 +editor.fx.0.y=61 +objectbench.height=109 +objectbench.width=861 +package.divider.horizontal=0.6 +package.divider.vertical=0.768 +package.editor.height=377 +package.editor.width=750 +package.editor.x=26 +package.editor.y=198 +package.frame.height=600 +package.frame.width=901 +package.numDependencies=3 +package.numTargets=6 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=StackTester +target1.showInterface=false +target1.type=AbstractTarget +target1.width=100 +target1.x=170 +target1.y=190 +target2.height=50 +target2.name=LinkedStack +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=330 +target2.y=140 +target3.height=50 +target3.name=LinkedStackTester +target3.showInterface=false +target3.type=UnitTestTargetJunit4 +target3.width=140 +target3.x=230 +target3.y=290 +target4.height=50 +target4.name=ArrayStackTester +target4.showInterface=false +target4.type=UnitTestTargetJunit4 +target4.width=130 +target4.x=40 +target4.y=290 +target5.height=50 +target5.name=ArrayStack +target5.showInterface=false +target5.type=ClassTarget +target5.width=120 +target5.x=20 +target5.y=140 +target6.height=50 +target6.name=Stack +target6.showInterface=false +target6.type=AbstractTarget +target6.width=80 +target6.x=180 +target6.y=60 diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStack.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStack.java new file mode 100644 index 0000000..dbcc08b --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStack.java @@ -0,0 +1,101 @@ + +/** + * Ein Stack basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStack extends Stack +{ + /** + * Enthält die Nutzdaten + */ + private Object[] daten; + /** + * Die Zahl gibt an, wie viele Elemente auf dem Stack liegen und damit auch, + * wie viele Werte im Datenarray gültig sind. + */ + private int anzahl; + + /** + * Erzeugt einen neuen leeren Stack + */ + public ArrayStack() + { + daten = new Object[10]; + anzahl = 0; + } + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + if (!isEmpty()) + { + return (T)daten[anzahl-1]; + } + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + if (!isEmpty()) + { + anzahl--; + return (T)daten[anzahl]; + } + return null; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + if (anzahl == daten.length) + { + Object[] tmp = new Object[2*daten.length]; + System.arraycopy(daten, 0, tmp, 0, daten.length); + daten = tmp; + } + daten[anzahl] = wert; + anzahl++; + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + return anzahl == 0; + } + + /** + * Gibt den Stack in String-Form aus. + * @return Die String-Repräsentation des Stacks + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + b.append("[ "); + for (int i = 0; i < anzahl; i++) + { + if (i > 0) + { + b.append(", "); + } + b.append(daten[i]); + } + b.append(" <"); + return b.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStackTester.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStackTester.java new file mode 100644 index 0000000..78ce2cc --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStackTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für den ArrayStack + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStackTester extends StackTester +{ + @Before + public void setUp() + { + theStack = new ArrayStack(); + } +} diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStack.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStack.java new file mode 100644 index 0000000..1082843 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStack.java @@ -0,0 +1,121 @@ +import java.math.BigInteger; + +/** + * Ein Stack basierend auf der Cantorschen Paarungsfunktion + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class CantorStack extends Stack +{ + /** + * Die Zahl, die den Stack repräsentiert + */ + private BigInteger stack; + + /** + * Erzeugt einen neuen leeren Stack + */ + public CantorStack() + { + stack = BigInteger.TWO; + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + return stack.equals(BigInteger.TWO); + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(Integer wert) + { + BigInteger y = BigInteger.valueOf(wert); + BigInteger x = stack; + BigInteger t1 = x.add(y); + BigInteger t2 = t1.add(BigInteger.ONE); + BigInteger t3 = t1.multiply(t2).shiftRight(1); + System.out.print("Push: (" + stack + " x " + wert + ") -> "); + stack = y.add(t3); + System.out.println(stack); + } + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public Integer top() + { + if (isEmpty()) + { + return null; + } + BigInteger top = topInt(); + System.out.println("Top: " + top); + return top.intValue(); + } + + private BigInteger topInt() + { + return stack.subtract(f(q(stack))); + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public Integer pop() + { + if (isEmpty()) + { + return null; + } + BigInteger top = topInt(); + System.out.print("Pop: " + stack + " -> ("); + stack = q(stack).subtract(top); + System.out.println(stack + "," + top +")"); + return top.intValue(); + } + + private BigInteger f(BigInteger w) + { + return w.multiply(w.add(BigInteger.ONE)).shiftRight(1); + } + + private BigInteger q(BigInteger z) + { + return z.shiftLeft(3).add(BigInteger.ONE).sqrt().subtract(BigInteger.ONE).shiftRight(1); + } + + /** + * Gibt den Stack in String-Form aus. + * @return Die String-Repräsentation des Stacks + */ + @Override + public String toString() + { + String ergebnis = " <"; + CantorStack s = new CantorStack(); + while(!this.isEmpty()) + { + Integer top = pop(); + s.push(top); + ergebnis = top + ergebnis; + if (!isEmpty()) + { + ergebnis = ", " + ergebnis; + } + } + while(!s.isEmpty()) + { + push(s.pop()); + } + return "[ " + ergebnis; + } +} diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStackTester.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStackTester.java new file mode 100644 index 0000000..644ce0e --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStackTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für den LinkedStack + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class CantorStackTester extends StackTester +{ + @Before + public void setUp() + { + theStack = new CantorStack(); + } +} diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStack.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStack.java new file mode 100644 index 0000000..2482fce --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStack.java @@ -0,0 +1,115 @@ + +/** + * Ein Stack basierend auf einer verketteten Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedStack extends Stack +{ + /** + * Das oberste Element des Stacks + */ + private Listenknoten topNode; + + /** + * Erzeugt einen neuen leeren Stack + */ + public LinkedStack() + { + topNode = null; + } + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + if (!isEmpty()) + { + return topNode.daten; + } + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + T top = null; + if (!isEmpty()) + { + top = topNode.daten; + topNode = topNode.nachfolger; + } + return top; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + topNode = new Listenknoten(wert, topNode); + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + return topNode == null; + } + + /** + * Ein Listenknoten, wie er bei den verketteten Listen verwendet wurde. + * Diesmal allerdings als innere Klasse + */ + private class Listenknoten + { + /** + * Der Datenwert des Listenknotens + */ + public T daten; + /** + * Der Nachfolger des Listenknotens + */ + public Listenknoten nachfolger; + + /** + * Erzeugt einen neuen Listenknoten + * + * @param daten Der Datenwert des Knotens + * @param nachfolger Der Nachfolger des Knotens + */ + public Listenknoten(T daten, Listenknoten nachfolger) + { + this.daten = daten; + this.nachfolger = nachfolger; + } + } + + /** + * Gibt den Stack in String-Form aus. + * @return Die String-Repräsentation des Stacks + */ + @Override + public String toString() + { + String ergebnis = " <"; + Listenknoten k = this.topNode; + while(k != null) + { + ergebnis = k.daten + ergebnis; + if (k.nachfolger != null) + ergebnis = ", " + ergebnis; + k = k.nachfolger; + } + return "[ " + ergebnis; + } +} diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStackTester.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStackTester.java new file mode 100644 index 0000000..aae6871 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStackTester.java @@ -0,0 +1,16 @@ +import org.junit.Before; + +/** + * Testklasse für den LinkedStack + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class LinkedStackTester extends StackTester +{ + @Before + public void setUp() + { + theStack = new LinkedStack(); + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/README.TXT b/Quellcodes/Alg_DS_Stack/02_stack_loes/README.TXT new file mode 100644 index 0000000..e45dacd --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Stack +PROJEKTZWECK: Zwei Implementationen des ADTs Stack +VERSION oder DATUM: Oktober 2020 +WIE IST DAS PROJEKT ZU STARTEN: Implementieren Sie den ArrayStack oder den LinkedStack. Führen Sie dann bei den entsprechenden Tester-Klassen "Alles testen" aus. +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/Stack.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/Stack.java new file mode 100644 index 0000000..332c28a --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/Stack.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Stack +{ + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); +} diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/StackTester.java b/Quellcodes/Alg_DS_Stack/02_stack_loes/StackTester.java new file mode 100644 index 0000000..e0abdd1 Binary files /dev/null and b/Quellcodes/Alg_DS_Stack/02_stack_loes/StackTester.java differ diff --git a/Quellcodes/Alg_DS_Stack/02_stack_loes/package.bluej b/Quellcodes/Alg_DS_Stack/02_stack_loes/package.bluej new file mode 100644 index 0000000..901d4c3 --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/02_stack_loes/package.bluej @@ -0,0 +1,93 @@ +#BlueJ package file +dependency1.from=StackTester +dependency1.to=Stack +dependency1.type=UsesDependency +dependency2.from=CantorStackTester +dependency2.to=CantorStack +dependency2.type=UsesDependency +dependency3.from=LinkedStackTester +dependency3.to=LinkedStack +dependency3.type=UsesDependency +dependency4.from=ArrayStackTester +dependency4.to=ArrayStack +dependency4.type=UsesDependency +editor.fx.0.height=709 +editor.fx.0.width=1184 +editor.fx.0.x=14 +editor.fx.0.y=113 +objectbench.height=121 +objectbench.width=840 +package.divider.horizontal=0.6 +package.divider.vertical=0.7668488160291439 +package.editor.height=414 +package.editor.width=729 +package.editor.x=914 +package.editor.y=77 +package.frame.height=649 +package.frame.width=880 +package.numDependencies=4 +package.numTargets=8 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=StackTester +target1.showInterface=false +target1.type=AbstractTarget +target1.width=100 +target1.x=170 +target1.y=190 +target2.height=50 +target2.name=CantorStack +target2.showInterface=false +target2.type=ClassTarget +target2.width=100 +target2.x=420 +target2.y=220 +target3.height=50 +target3.name=CantorStackTester +target3.showInterface=false +target3.type=UnitTestTargetJunit4 +target3.width=140 +target3.x=400 +target3.y=290 +target4.height=50 +target4.name=LinkedStack +target4.showInterface=false +target4.type=ClassTarget +target4.width=130 +target4.x=400 +target4.y=130 +target5.height=50 +target5.name=LinkedStackTester +target5.showInterface=false +target5.type=UnitTestTargetJunit4 +target5.width=140 +target5.x=230 +target5.y=290 +target6.height=50 +target6.name=ArrayStackTester +target6.showInterface=false +target6.type=UnitTestTargetJunit4 +target6.width=130 +target6.x=40 +target6.y=290 +target7.height=50 +target7.name=ArrayStack +target7.showInterface=false +target7.type=ClassTarget +target7.width=120 +target7.x=0 +target7.y=140 +target8.height=50 +target8.name=Stack +target8.showInterface=false +target8.type=AbstractTarget +target8.width=80 +target8.x=180 +target8.y=80 diff --git a/Quellcodes/Alg_DS_Stack/readme.adoc b/Quellcodes/Alg_DS_Stack/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Stack/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Sudoku/.gitignore b/Quellcodes/Alg_DS_Sudoku/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/BekannteZahl.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/BekannteZahl.java new file mode 100644 index 0000000..8c573dc --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/BekannteZahl.java @@ -0,0 +1,59 @@ +import java.awt.*; + +/** + * Repräsentiert eine "sicher" eingetragene Zahl in einer Sudoku-Zelle + * Kann eine Vorgabe sein oder eine durch Schlussfolgerungen gesetzte Zahl sein. + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class BekannteZahl implements Eintrag +{ + /** + * Der Wert der bekannten Zahl + */ + private int wert; + + /** + * Die Farbe, in der die Zahl gezeichnet werden soll (für Backtracking-Situationen) + */ + private Color farbe; + + /** + * Erzeugt eine neue bekannte Zahl + * @param w Der Wert der Zahl + */ + public BekannteZahl(int w) + { + wert = w; + farbe = Color.BLACK; + } + + /** + * Markiert die Zahl, dies bedeutet, dass sie beim Backtracking "geraten" wurde + */ + public void setMarkiert() + { + farbe = new Color(140, 70, 120); + } + + /** + * Zeichnet die Zahl auf ein Graphics-Objekt + * Sollte nicht direkt aufgerufen werden. + */ + public void zeichneDich(Graphics g, Rectangle r) + { + g.setColor(farbe); + g.setFont(g.getFont().deriveFont(65.0f)); + SudokuPanel.drawCenteredString(g, ""+wert, r); + } + + /** + * Gibt den Zahlwert der bekannten Zahl zurück + * @return Der Wert der Zahl + */ + public int getZahl() + { + return wert; + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/BitSet.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/BitSet.java new file mode 100644 index 0000000..2f8bf0a --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/BitSet.java @@ -0,0 +1,294 @@ +import java.util.ArrayList; + +/** + * Eine Set basierend auf Bitvektoren + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ +public class BitSet extends Set +{ + private ArrayList daten; + + /** + * Erzeugt eine neue leere Set + */ + public BitSet() + { + daten = new ArrayList(); + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl()]; + int index = 0; + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i)) + { + ergebnis[index] = i; + index++; + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + for (int v : daten) + { + if (v != 0) + { + return false; + } + } + return true; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int x) + { + if (x >= 32*daten.size() || x < 0) + { + return false; + } + int i = x / 32; + int j = x % 32; + int mask = 1 << j; + return (daten.get(i) & mask) != 0; + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + int laenge = 0; + for (int i : daten) + { + laenge += Integer.bitCount(i); + } + return laenge; + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + BitSet ergebnis = new BitSet(); + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & ~(bs.daten.get(i))); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int x) + { + if (x >= 0) + { + int i = x / 32; + daten.ensureCapacity(i+1); + while(i >= daten.size()) + { + daten.add(0); + } + int j = x % 32; + int mask = 1 << j; + daten.set(i, daten.get(i) | mask); + } + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + int a = daten.get(i); + int b = bs.daten.get(i); + if ((a & ~b) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + return false; + } + } + return true; + } + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + BitSet ergebnis = new BitSet(); + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) | bs.daten.get(i)); + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + ergebnis.daten.add(bs.daten.get(i)); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + int[] a = s.alsArray(); + ergebnis.daten.addAll(daten); + for (int n : a) + { + ergebnis.einfuegen(n); + } + } + return ergebnis; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + BitSet ergebnis = new BitSet(); + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & bs.daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int x) + { + if (x < 32*daten.size() && x >= 0) + { + int i = x / 32; + int j = x % 32; + int mask = ~(1 << j); + daten.set(i, daten.get(i) & mask); + } + } + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + if (daten.get(i) != bs.daten.get(i)) + { + return false; + } + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + if (bs.daten.get(i) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + return super.gleich(s); + } + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Eintrag.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Eintrag.java new file mode 100644 index 0000000..41959af --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Eintrag.java @@ -0,0 +1,16 @@ +import java.awt.*; + +/** + * Ein Eintrag in einer Sudoku-Zelle, kann entweder eine feststehende Zahl sein oder eine Menge von Kandidaten + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public interface Eintrag +{ + /** + * Zeichnet den Eintrag auf ein Graphics-Objekt + * Sollte nicht direkt aufgerufen werden. + */ + void zeichneDich(Graphics g, Rectangle ziel); +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Kandidatenmenge.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Kandidatenmenge.java new file mode 100644 index 0000000..5305d01 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Kandidatenmenge.java @@ -0,0 +1,56 @@ +import java.awt.*; + +/** + * Repräsentiert eine Kandidatenmenge für eine Sudoku-Zelle + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class Kandidatenmenge extends BitSet implements Eintrag +{ + /** + * Erzeugt eine neue Kandidatenmenge bestehend aus den Zahlen von 1 bis 9 + */ + public Kandidatenmenge() + { + for (int i = 1; i <= 9; i++) + { + this.einfuegen(i); + } + } + + /** + * Zeichnet die Kandidatenmenge auf ein Graphics-Objekt + * Sollte nicht direkt aufgerufen werden. + */ + public void zeichneDich(Graphics g, Rectangle r) + { + if (istLeer()) + { + g.setColor(Color.RED); + ((Graphics2D)g).setStroke(new BasicStroke(3)); + g.drawLine(r.x,r.y,r.x+r.width, r.y+r.height); + g.drawLine(r.x,r.y+r.height,r.x+r.width, r.y); + } + else + { + g.setColor(Color.BLUE); + g.setFont(g.getFont().deriveFont(20.0f)); + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 3; j++) + { + int n = 3*j+i+1; + if (enthaelt(n)) + { + int x = (int)(r.getX()+i*r.getWidth()/3); + int y = (int)(r.getY()+j*r.getHeight()/3); + int w = (int)(r.getWidth()/3); + int h = (int)(r.getHeight()/3); + SudokuPanel.drawCenteredString(g, ""+n, x, y, w, h); + } + } + } + } + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/README.TXT b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/README.TXT new file mode 100644 index 0000000..b1e254d --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Sudoku +PROJEKTZWECK: Implementieren Sie einen Teil eines Sudoku-Löser +VERSION oder DATUM: Dezember 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ SudokuGitter, entweder ohne Parameter oder mit einem int-Parameter (von 0 bis 399) +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Set.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Set.java new file mode 100644 index 0000000..60ec0f2 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/Set.java @@ -0,0 +1,107 @@ +/** + * Schnittstelle des ADTs Set + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ + +public abstract class Set +{ + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public abstract void einfuegen(int wert); + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public abstract void entfernen(int wert); + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public abstract boolean enthaelt(int wert); + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert. + */ + public abstract Set schnittmenge(Set s); + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public abstract Set vereinigungsmenge(Set s); + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public abstract boolean untermenge(Set s); + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public abstract Set differenz(Set s); + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public abstract int anzahl(); + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public abstract boolean istLeer(); + + protected abstract int[] alsArray(); + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + return untermenge(s) && s.untermenge(this); + } + + /** + * Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück + * @return Ein String, der alle Elemente der Menge aufzählt. + */ + @Override + public String toString() + { + if (istLeer()) + { + return "{ }"; + } + StringBuilder sb = new StringBuilder(); + for(int v : alsArray()) + { + if (sb.length() == 0) + { + sb.append("{ "); + } + else + { + sb.append(", "); + } + sb.append(v); + } + sb.append(" }"); + return sb.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuFrame.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuFrame.java new file mode 100644 index 0000000..8473207 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuFrame.java @@ -0,0 +1,194 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +import java.util.concurrent.atomic.AtomicBoolean; + +/** + * + * Ein Fenster, um das Sudoku-Spiel darzustellen + * Hier sollte nichts verändert werden. + * @version Dezember 2020 + * @author Rainer Helfrich + */ + +public class SudokuFrame extends JFrame { + + Point backtrackingPosition; + int nextBacktrackIndex; + JButton btnBacktrack; + SudokuGitter dasSpiel; + JLabel lblSackgasse; + + public SudokuFrame(SudokuGitter sp, SudokuFrame parent) { + + super(); + backtrackingPosition = null; + dasSpiel = sp; + nextBacktrackIndex = -1; + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 800; + int frameHeight = 900; + setSize(frameWidth, frameHeight); + + if (parent != null) + { + parent.setEnabled(false); + setLocation(parent.getX() + 20, parent.getY() + 20); + } + else + { + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + } + setTitle("Sudokus lösen"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + + SudokuPanel sudokuPanel1 = new SudokuPanel(sp); + sudokuPanel1.setBounds(8, 8, 720, 720); + cp.add(sudokuPanel1); + + final JLabel lblGewonnen = new JLabel("Spiel gelöst"); + lblGewonnen.setBounds(220, 770, 400, 16); + lblGewonnen.hide(); + cp.add(lblGewonnen); + + lblSackgasse = new JLabel("Spiel so nicht lösbar -> Backtracking nötig"); + lblSackgasse.setBounds(220, 770, 400, 16); + lblSackgasse.setForeground(Color.RED); + lblSackgasse.hide(); + cp.add(lblSackgasse); + + final JButton btnKandidatenListe = new JButton("Kandidatenmengen erstellen"); + final JButton btnEintrag = new JButton("Eintragen"); + final JButton btnAutomatisch = new JButton("Automatisch"); + btnAutomatisch.setBounds(8, 770, 200, 24); + btnEintrag.setEnabled(false); + btnBacktrack = new JButton("Backtracking-Schritt"); + btnBacktrack.setEnabled(false); + btnKandidatenListe.setBounds(8, 740, 200, 24); + + AtomicBoolean bEintragungMoeglich = new AtomicBoolean(false); + ActionListener alKandidaten = new ActionListener() { + public void actionPerformed(ActionEvent evt) { + bEintragungMoeglich.set(sp.kandidatenMengenErstellen()); + if (bEintragungMoeglich.get()) + { + btnEintrag.setEnabled(true); + } + else // Fehler -> Zurückgehen + { + btnBacktrack.setEnabled(false); + btnAutomatisch.setEnabled(false); + lblSackgasse.show(); + } + btnKandidatenListe.setEnabled(false); + sudokuPanel1.repaint(); + } + }; + ActionListener alEintrag = new ActionListener() { + public void actionPerformed(ActionEvent evt) { + bEintragungMoeglich.set(sp.eintragen()); + if (bEintragungMoeglich.get()) // es war eine Eintragung möglich + { + btnKandidatenListe.setEnabled(true); + } + else // Man muss raten -> Backtracking + { + btnBacktrack.setEnabled(true); + btnAutomatisch.setEnabled(false); + backtrackingPosition = sp.getPositionVonKleinsterKandidatenmenge(); + if (backtrackingPosition == null) + { + if (sp.istGeloest()) + { + lblGewonnen.show(); + btnBacktrack.setEnabled(false); + btnEintrag.setEnabled(false); + } + return; + } + Kandidatenmenge km = (Kandidatenmenge)sp.getEintrag(backtrackingPosition.x, backtrackingPosition.y); + nextBacktrackIndex = 0; + btnBacktrack.setText("Backtracking-Schritt 1 von " + km.anzahl()); + } + btnEintrag.setEnabled(false); + sudokuPanel1.repaint(); + } + }; + + btnKandidatenListe.addActionListener(alKandidaten); + cp.add(btnKandidatenListe); + cp.add(btnAutomatisch); + + btnEintrag.setBounds(220, 740, 200, 24); + btnEintrag.addActionListener(alEintrag); + cp.add(btnEintrag); + + btnAutomatisch.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + if (btnEintrag.isEnabled()) + { + alEintrag.actionPerformed(null); + } + while(true) + { + alKandidaten.actionPerformed(null); + if (!bEintragungMoeglich.get()) + { + break; + } + alEintrag.actionPerformed(null); + if (!bEintragungMoeglich.get()) + { + break; + } + } + } + }); + + btnBacktrack.setBounds(220+212, 740, 200, 24); + btnBacktrack.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + int versuch = ((Kandidatenmenge)sp.getEintrag(backtrackingPosition.x, backtrackingPosition.y)).alsArray()[nextBacktrackIndex]; + SudokuGitter spNeu = sp.klonErzeugen(backtrackingPosition.x, backtrackingPosition.y, versuch); + } + }); + cp.add(btnBacktrack); + + addWindowListener(new WindowAdapter(){ + public void windowClosing(WindowEvent e){ + if (parent != null) + { + parent.setEnabled(true); + parent.nextBacktrackStep(); + } + } + }); + setVisible(true); + } + + private void nextBacktrackStep() + { + if (this.backtrackingPosition != null) + { + Kandidatenmenge km = (Kandidatenmenge)dasSpiel.getEintrag(backtrackingPosition.x, backtrackingPosition.y); + nextBacktrackIndex++; + if (nextBacktrackIndex >= km.anzahl()) + { + btnBacktrack.setEnabled(false); + btnBacktrack.setText("Backtracking-Schritt"); + lblSackgasse.show(); + } + else + { + btnBacktrack.setText("Backtracking-Schritt "+(nextBacktrackIndex+1)+" von " + km.anzahl()); + } + } + + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuGitter.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuGitter.java new file mode 100644 index 0000000..6aad1c9 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuGitter.java @@ -0,0 +1,327 @@ +import java.util.ArrayList; +import java.util.function.Predicate; +import java.awt.Point; + +/** + * Repräsentiert ein 9x9-Sudoku-Gitter + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class SudokuGitter +{ + /** + * Die einzelnen Felder des Gitters + * Erster Index = x-Koordinate + * Zweiter Index = y-Koordinate + */ + private Eintrag[][] felder; + + /** + * Verweist auf das Fenster, in dem das Gitter dargestellt wird + */ + private SudokuFrame theFrame; + + /** + * Erzeugt ein neues Gitter mit dem Rätsel Nr. 100 + */ + public SudokuGitter() + { + this(100); + } + + /** + * Erzeugt ein neues Gitter mit dem Rätsel Nr. 100 + * @param nummer Die Nummer des Spiels + */ + public SudokuGitter(int nummer) + { + this(SudokuRaetselDB.getRaetsel(nummer)); + } + + /** + * Erzeugt ein neues Gitter mit durch den String beschriebenen Spiel + * @param spiel Eine String-Codierung des Spiels + */ + public SudokuGitter(String spiel) + { + this(spiel, null); + } + + /** + * Erzeugt ein neues Gitter als Kopie eines anderen Gitters + * @param vorlage Die Vorlage für das neue Gitter + */ + private SudokuGitter(SudokuGitter vorlage) + { + this(vorlage.toString(), vorlage.theFrame); + } + + /** + * Erzeugt ein neues Gitter mit durch den String beschriebenen Spiel + * @param spiel Eine String-Codierung des Spiels + * @param parent Das übergeordnete Fenster des neu erzeugten Fensters (kann auch null sein) + */ + private SudokuGitter(String spiel, SudokuFrame parent) + { + felder = new Eintrag[9][9]; + char[] cSpiel = spiel.toCharArray(); + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (cSpiel[9*j+i] != '.') + { + felder[i][j] = new BekannteZahl(Integer.parseInt(""+cSpiel[9*j+i])); + } + } + } + theFrame = new SudokuFrame(this, parent); + } + + /** + * Erzeugt einen Klon des aktuellen Gitters und setzt eine Zelle auf einen bestimmten Wert + * @param x Die x-Koordinate des zu setzenden Feldes + * @param y Die y-Koordinate des zu setzenden Feldes + * @param wert Der zu setzende Wert + * @return Die Kopie des Gitters + */ + public SudokuGitter klonErzeugen(int x, int y, int wert) + { + SudokuGitter sp = new SudokuGitter(this); + BekannteZahl raten = new BekannteZahl(wert); + raten.setMarkiert(); + sp.felder[x][y] = raten; + sp.theFrame.setTitle("Sudokus lösen: Versuch (" + x + "," + y + ") <- " + wert); + return sp; + } + + /** + * Wandelt das Gitter in seine String-Darstellung um + * @return Eine String-Darstellung des Gitters + */ + public String toString() + { + StringBuilder sb = new StringBuilder(); + for (int y = 0; y < 9; y++) + { + for (int x = 0; x < 9; x++) + { + if (felder[x][y] instanceof BekannteZahl) + { + sb.append(""+((BekannteZahl)felder[x][y]).getZahl()); + } + else + { + sb.append("."); + } + } + } + return sb.toString(); + } + + /** + * Prüft, ob das Spiel gelöst ist + * @return true, wenn das Spiel gelöst ist; false sonst + */ + public boolean istGeloest() + { + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (!(felder[i][j] instanceof BekannteZahl)) + { + return false; + } + } + } + return true; + } + + /** + * Trägt eine Zahl ins Gitter ein, wenn es möglich ist. Wenn ja, löscht es alle Kandidatenmengen aus dem Gitter + * @return true, wenn eine Eintragung möglich war; false sonst + */ + public boolean eintragen() + { + boolean ergebnis = nackterEinerEintragen(); + if (!ergebnis) + { + ergebnis = versteckterEinerEintragen(); + } + if (ergebnis) + { + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (felder[i][j] instanceof Kandidatenmenge) + { + felder[i][j] = null; + } + } + } + } + return ergebnis; + } + + /** + * Gibt den Eintrag an der gewünschten Koordinate zurück + * @param x Die x-Koordinate des Eintrags (0 bis 8) + * @param y Die y-Koordinate des Eintrags (0 bis 8) + * @return Der Eintrag an der gewünschten Koordinate + */ + public Eintrag getEintrag(int x, int y) + { + return felder[x][y]; + } + + /** + * Gibt alle Einträge der gewünschten Zeile zurück + * @param z Die Nummer der Zeile (0 bis 8) + * @return Ein Array mit allen Einträgen der Zeile + */ + private Eintrag[] getZeile(int z) + { + return getZeile(z, null); + } + + /** + * Gibt alle Einträge der gewünschten Zeile zurück, die einem Prädikat entsprechen + * @param z Die Nummer der Zeile (0 bis 8) + * @param pred Das Prädikat, mit dem die Einträge geprüft werden sollen; null für alle Einträge + * @return Ein Array mit allen Einträgen der Zeile, die dem Prädikat entsprechen + */ + private Eintrag[] getZeile(int z, Predicate pred) + { + ArrayList a = new ArrayList(); + for (int i = 0; i < 9; i++) + { + if (pred == null || pred.test(felder[i][z])) + a.add(felder[i][z]); + } + return a.toArray(new Eintrag[0]); + } + + /** + * Gibt alle Einträge der gewünschten Spalte zurück + * @param s Die Nummer der Spalte (0 bis 8) + * @return Ein Array mit allen Einträgen der Spalte + */ + private Eintrag[] getSpalte(int s) + { + return getSpalte(s, null); + } + + /** + * Gibt alle Einträge der gewünschten Spalte zurück, die einem Prädikat entsprechen + * @param s Die Nummer der Spalte (0 bis 8) + * @param pred Das Prädikat, mit dem die Einträge geprüft werden sollen; null für alle Einträge + * @return Ein Array mit allen Einträgen der Spalte, die dem Prädikat entsprechen + */ + private Eintrag[] getSpalte(int s, Predicate pred) + { + ArrayList a = new ArrayList(); + for (int i = 0; i < 9; i++) + { + if (pred == null || pred.test(felder[s][i])) + a.add(felder[s][i]); + } + return a.toArray(new Eintrag[0]); + } + + /** + * Gibt alle Einträge des Blocks zurück, in dem die Zelle (x,y) liegt + * @param x Die x-Koordinate der Zelle (0 bis 8) + * @param y Die y-Koordinate der Zelle (0 bis 8) + * @return Ein Array mit allen Einträgen des Blocks + */ + private Eintrag[] getBlockVon(int x, int y) + { + return getBlockVon(x, y, null); + } + + /** + * Gibt alle Einträge des Blocks zurück, in dem die Zelle (x,y) liegt, sonfern diese einem Prädikat entsprechen + * @param x Die x-Koordinate der Zelle (0 bis 8) + * @param y Die y-Koordinate der Zelle (0 bis 8) + * @return Ein Array mit allen Einträgen des Blocks, die dem Prädikat entsprechen + */ + private Eintrag[] getBlockVon(int x, int y, Predicate pred) + { + ArrayList a = new ArrayList(); + int xs = (x/3)*3; + int ys = (y/3)*3; + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 3; j++) + { + if (pred == null || pred.test(felder[xs+i][ys+j])) + a.add(felder[xs+i][ys+j]); + } + } + return a.toArray(new Eintrag[0]); + } + + /** + * Trägt in allen Zellen des Gitters, an denen bisher null steht, die Kandidatenmenge ein + * @return true, wenn alle Kandidatenmengen nichtleer sind; false sonst + */ + public boolean kandidatenMengenErstellen() + { + //# TODO: Vervollständigen Sie die Methode. + //# Sie soll an alle Stellen im zweidimensionalen Array felder, die derzeit null enthalten, eine Kandidatenmenge setzen + //# Falls eine der Kandidatenmengen leer ist, soll false zurückgegeben werden, andernfalls true. + return true; + } + + /** + * Trägt eine Zahl nach der "Nackter Einer"-Technik ins Gitter ein. + * @return true, wenn eine solche Eintragung möglich war; false sonst + */ + private boolean nackterEinerEintragen() + { + //# TODO: Vervollständigen Sie die Methode. + //# Sie soll einen (!) Eintragungsschritt nach der "Nackter Einer"-Technik machen + //# und true zurückgeben, wenn das Eintragen möglich war. Andernfalls soll false zurückgeliefert werden. + //# Es ist wirklich wichtig, dass Sie immer nur einen Eintragungsschritt machen, da sonst falsche Ergebnisse entstehen können. + //# Zum Eintragen erzeugen Sie ein neues Objekt vom Typ BekannteZahl mit der entsprechenden Ziffer als Parameter und + //# tragen Sie es in das zweidimensionale Array felder ein. + + return false; + } + + /** + * Trägt eine Zahl nach der "Versteckter Einer"-Technik ins Gitter ein. + * @return true, wenn eine solche Eintragung möglich war; false sonst + */ + private boolean versteckterEinerEintragen() + { + //# TODO: Vervollständigen Sie die Methode. + //# Sie soll einen (!) Eintragungsschritt nach der "Versteckter Einer"-Technik machen + //# und true zurückgeben, wenn das Eintragen möglich war. Andernfalls soll false zurückgeliefert werden. + //# Es ist wirklich wichtig, dass Sie immer nur einen Eintragungsschritt machen, da sonst falsche Ergebnisse entstehen können. + //# Zum Eintragen erzeugen Sie ein neues Objekt vom Typ BekannteZahl mit der entsprechenden Ziffer als Parameter und + //# tragen Sie es in das zweidimensionale Array felder ein. + + return false; + } + + /** + * Sucht die kleinste Kandidatenmenge im Gitter und gibt ihre Koordinaten als Point zurück + * @return Die Koordinaten der kleinsten Kandidatenmenge; null, wenn keine Kandidatenmenge im Gitter steht + */ + public Point getPositionVonKleinsterKandidatenmenge() + { + Point p = null; + //# TODO: Vervollständigen Sie diese Methode. + //# Sie gibt die Position der Kandidatenmenge zurück, die die wenigsten Werte enthält. + //# Der x-Wert des Point-Objekts ist die erste Koordinate im zweidimensionalen Array felder, der y-Wert die zweite + //# Beispiel zum Erzeugen eines Point: p = new Point(spalte, zeile); + //# Falls kein Eintrag in felder eine Kandidatenmenge ist, soll null zurückgegeben werden. + //# Dies ist der Fall, wenn das Rätsel gelöst ist. + + return p; + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuPanel.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuPanel.java new file mode 100644 index 0000000..1160643 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuPanel.java @@ -0,0 +1,99 @@ +import javax.swing.*; +import java.awt.*; + +/** + * Ein Panel, in dem das Sudoku-Spiel gezeichnet wird. + * Hier sollte nichts verändert werden. + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class SudokuPanel extends JPanel +{ + /** + * Das Spiel, das dargestellt werden soll + */ + private SudokuGitter dasSpiel; + + /** + * Erzeugt ein neues Panel + * @param s Das Spiel, das dargestellt werden soll. + */ + public SudokuPanel(SudokuGitter s) + { + dasSpiel = s; + } + + /** + * Zeichnet das Spiel auf ein Graphics-Objekt + * @param gg Das Graphics-Objekt, auf das gezeichnet werden soll + */ + public void paintComponent(Graphics gg) + { + Graphics2D g = (Graphics2D)gg; + g.setColor(Color.WHITE); + g.fillRect(0,0,getWidth(),getHeight()); + g.setColor(Color.BLACK); + g.setStroke(new BasicStroke(5)); + int w = getWidth()-5; + int h = getHeight()-5; + g.drawRect(2, 2, w/3, h); + g.drawRect(2+w/3, 2, w/3, h); + g.drawRect(2+2*w/3, 2, getWidth()-2*w/3-5, h); + g.drawRect(2, 2, w, h/3); + g.drawRect(2, 2+h/3, w, h/3); + g.drawRect(2, 2+2*w/3, w, getHeight()-2*h/3-5); + g.setStroke(new BasicStroke(2)); + for (int i = 1; i < 9; i++) { + g.drawLine(2+i*w/9, 2, 2+i*w/9, h); + g.drawLine(2, 2+i*h/9, w, 2+i*h/9); + } + int cellWidth = w/9; + int cellHeight = h/9; + for (int i = 0; i < 9; i++) + { + int x = 2+i*w/9; + for (int j = 0; j < 9; j++) + { + int y = 2+j*h/9; + Eintrag e = dasSpiel.getEintrag(i, j); + if (e == null) + { + continue; + } + Rectangle r = new Rectangle(x+5, y+5, cellWidth-10, cellHeight-10); + e.zeichneDich(gg, r); + } + } + } + + /** + * Zeichnet einen String in einem Rechteck zentriert auf ein Graphics-Objekt + * @param g Das Graphics-Objekt, auf das gezeichnet werden soll + * @param text Der zu zeichnende Text + * @param rect Der Bereich, in den der Text zentriert werden soll + */ + public static void drawCenteredString(Graphics g, String text, Rectangle rect) { + drawCenteredString(g, text, rect.x, rect.y, rect.width, rect.height); + } + + /** + * Zeichnet einen String in einem Rechteck zentriert auf ein Graphics-Objekt + * @param g Das Graphics-Objekt, auf das gezeichnet werden soll + * @param text Der zu zeichnende Text + * @param x x-Koordinate der linken oberen Ecke des Rechtecks + * @param y y-Koordinate der linken oberen Ecke des Rechtecks + * @param w Breite des Rechtecks + * @param h Höhe des Rechtecks + */ + public static void drawCenteredString(Graphics g, String text, int x, int y, int w, int h) { + // Get the FontMetrics + FontMetrics metrics = g.getFontMetrics(); + // Determine the X coordinate for the text + x += (w - metrics.stringWidth(text)) / 2; + // Determine the Y coordinate for the text (note we add the ascent, as in java 2d 0 is top of the screen) + y += ((h - metrics.getHeight()) / 2) + metrics.getAscent(); + // Draw the String + g.drawString(text, x, y); + } + +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuRaetselDB.java b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuRaetselDB.java new file mode 100644 index 0000000..dd7eacb --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/SudokuRaetselDB.java @@ -0,0 +1,444 @@ + +/** + * Eine "Datenbank" mit 400 Sudoku-Rätseln + * + * @author Rainer Helfrich + * @version Dezember 2020 + * + * Rätsel erzeugt mit https://qqwing.com/generate.html + */ +public class SudokuRaetselDB +{ + /** + * Gibt das gewünschte Rätsel zurück + * @param nummer Die Nummer des Rätsels + * @return Das Rätsel als String codiert. + */ + public static String getRaetsel(int nummer) + { + if (nummer < 0 || nummer >= 400) + { + return "................................................................................."; + } + System.out.print("Rätsel Nr. " + nummer + " ("); + if (nummer < 100) + { + System.out.print("einfach"); + } + else if (nummer < 200) + { + System.out.print("mittel"); + } + else + { + if (nummer >= 300) + System.out.print("sehr "); + System.out.print("schwer"); + } + System.out.println(")"); + return raetsel[nummer]; + } + + private static String[] raetsel = { + "..42...18..2.4....1..68..9.26...9..7...7..28..87...9.3...4.....4..........8.3..2.", + ".5.6.3......2.......3.7.....2..69.574.....8.97..54..26....2.6......8..34...9.62..", + ".642....99...5....1.54.8..624....3.........1..8.3.1452.2.....6.......8.3.....42..", + "...3..15.....1.......7.......36...4..7.2853..8.1..76..7..52...3.2.8..4...3...6...", + "6..21..9...85....6.4.9..82.1..4.6.5.....7.2.94.9..5.7...........8.......5.264....", + "5...6...973.2..4.....5..3......2.6..3........8..4......5.9.8.7..2.....356.7...9.8", + ".9....45.......3...5..3.127..849..7..29.538...7.2...9..8....74...........43..591.", + "1......4.8.7..2.1.2.......9..9..43..3.8...7.4..286...........7173..9.48......69..", + "...693..2..4...........13......8.9......4..37...1.98..4.1...69.37......1...2.6...", + ".8.....4........6...931....8.649..237.........4..3..174...61.9..92....3...7......", + "...6.8.....59.4.3..9.2.....5.7........672...5.4...3..2.......4.862......9....53..", + "..9..6.4....4...2.5......7......7.....5......76...9.....1.5.3..3.462.5..9...741..", + "...2.....9..71....1............8.2.78..9....37.91....5.8..7.43......45.84...5.1.2", + ".93..518..2.....34..51....7.7...3......981.....927......249..........8....1..29..", + "8.....2..2.9.7..38.....1.7......6......3.2.41.8479.3..31....78..........76.......", + "..47.....56...917..1.6.54.8.5..367.4..3..851.....7........4............9......85.", + "6....34.......539........6...6.......35.4982...968..7..435....9.2.....4.......2..", + "...6.1.3..2.9.....85..27.6....8......3..5....5...6.......3.9.7.9.1.....6.7..1..59", + "..........8....1.49.1..7.2.......872....4..1.........3..85...3.7...91..5.5.42...8", + ".........7.....6....5.....8..9.283.717.69.....2.3..1.....8...1.5.6..18.3..8...7.2", + "3..91....4....59..1...2.......486...8...5.2........1...5.2...98.6..4.....1.6.9.4.", + ".37....1...............54...1.2.8..4.9..13.7.7.5.....14..............29835...97..", + ".1.9..8..5..1....286......3...3.8..7..5.26......5........6......87..2.9...9....56", + "...6952.7...4..3.8........5...9.3.5.....7...29...5...65....28.473..64...8........", + "5.......123.9.6.....9..53.44.5..3..7.1.6.9..576..4..133.....1........7....7.....6", + "..........8...9....9...1..26..4..89532..95.6...........14....8.96..2..1.......2.3", + ".78.41.5.4........9.15...48...3..5...42..7...8..95.71.137.....9......3...........", + "4.568.1..........6..831...9........33...5.8.2......95...1.3..25.2....3..8.4.6....", + "...5.7.1..7......2...9.......18..6..98.65.1..5.6.......3...2..7...13..8......8.9.", + "7.26....4.3...4....16......1....24..2.98167....3.9.....2....9.6.91.3.........7.1.", + "9.3....71....65..2..........1..........82..9.......5.6.3....1.7..92....32.7...86.", + ".2...896......9.5718..........29.6...6....24..4.....18........4..6...1..57.....2.", + "...7..4.5.......934....167....2.3.......1....562.9.....3..6791.2..13.........5...", + "149.2....3.8..............196...2.......4.76...2....84....74893.8..6..1...3......", + "2.157....56..8.....8...1...............246....16..7.4...8.2.6....746312...27....4", + "648.....79.73....5.5....18.3......6..65...734..4.......7..8..16........8..9..45..", + ".......4..7..39.....9..7..5..3...4...1.....28..4.....1.589.....2..7.41...3..1.8.9", + "9..........47...........9.31..98.......2.......5..1.74...87.4..3..1.25..257.3..1.", + "8..9...7..64...39.....542.8....6.......3.8.5..7..4......7..246...387....5....3...", + "8..5..7...9.........3.81.2...5.........162......7..6.2........1...92.58.9..6.3.7.", + "4..6.2............5.379.4...2...6.8375...8.6..3.4.....9.7.436.....9.......6.2....", + "....6....8.....9.4.............3......7..438.4..6.8..5..6..14.95..8..13..193..87.", + "....4.3..6.4.9..7..237....956....72...2......1....5.64.5.......9....3....3.....12", + ".............6.......79...2..4.....57.2.85...5....918.2...479.1.57......19.8...64", + "7..48.3.92...69......7...8..9.6..24.......9..5....36...5...........9.4......32.7.", + "..6.....2425...1.6.....3.5..13.9...4......38..4....2.9..8.......64.8....39...26..", + "..3..29..19.46..7.2..7.8..3..8.7...........3292....71........4..1...9...34.......", + "..7.4.....1...3...93.812....9...748...832.1.9.2..........9..........18..3815.4...", + "87..3.4...........1.29..7.8...21...4.19.87............3....5.9.9.73.....481.7....", + "........1.....19.58.........6..8....5...7..23.7.39.8..9...3.6....1625.3...2..9...", + "...6..1.9.....3.6.2....13.5..3.4.29....8.56.........5.4.9.3...2.2.....81....9....", + "3.....1...5..7...26...159.77.46........4..53..29..3.6....2....5....9......1......", + "4...8.6.297..2..5.8.3........4....7...8.7.2.4..7..5..9......5...5.3...4.......827", + "5...9..18...3..4........35.....6.2.3........7....53.9.41.82....3....9.2..795.1.4.", + "............4...89.......6...4.5.81...5.9.6.3..7.61..534.5......6.91.4..8.9.....7", + "...4.7.....45..937.56..9.......9..65..9..8..38..756.2.......7.....3.4.....2....5.", + "....5.89..3..6.7.15.7.....6.2.9.....7..8...........2...62.8...7..5..73629..3...8.", + ".7.....9.2.9.34.85...7.8..24..2.........57...7..8.96.......5.3........7..4..2..5.", + ".89.....3..475...1....38..4..5.....8...38..1.....42....17.2....43.517...5.2..4...", + "......59..68..41..4.1..2...5.2.....3..3..94.21......8.3...158..6......3..8.....5.", + "...6.7....9.....5..7...198.76...45.9...275...............8........1.67...81.52.94", + "..2......6..4....1.31.9....7..2.4....59.37.............7...2..62.3.6.....9.15.3..", + ".....3..1...98.....7..268...283...14.....496..61...7.2....78......6..2.3......6..", + "....8.......2.6.8.7..31.6..4....821..3.....7.21.67384.84.1...6.396..2............", + ".1...5......36..54....419.......8..36.5.9481.......67.....76435.4.18.7...........", + "........4.2..3.51.....2...3......18...29..7.5....8...9.8..1....1.4..789.39...845.", + "..5..693..3.24..5.6.97.......6...3.................4...4.6.5...37...26.....3..8.2", + "............3..1........3.78....25.63...6..2...248573..4..2.8..6...574....1..3..2", + "83.6.1.....2.....1..5.23....1.8......68....1......7..5.5.7........43....27..86.3.", + ".76..53.......27....2....89...21..6........5......7....3..5....15....93.6..89.2..", + "76..9...3......2.....587.1....2.....9.....1.....3...9....73..86.3...69.......85.2", + "..9...8..18.5...73.36....9...3...5...5.....6.61.....823...186.7.75.29............", + ".3.6...2...5.2..7..2..376..4.....1..8.1....67...4.6.58........1.....3.45..7..8.3.", + "......4.5.29..............6..8.6..9.....5..78.9.23.56...4.8....25...7..3.37.2..4.", + "19.........83.1.....58...........4.6.12.46.58.3.....9..6...413....95......3.....5", + ".4.............5....1..3..44.8..67.1.59....3.......8651..6......9675.3.......4..7", + "4..2865..2...37.9.....5...3...7.........2....7...9....82..7...69.6....3.5.3.6948.", + ".7.....6.......3.53..8.4....1.......7....8523..6..2..4.6.3.....5..7......341..7..", + ".3...7..15.42..9.8.2.58.......7.9.2.......195....4...7.5.81..32........9.......7.", + "96.4...13....968..5..8..9.4..4..3..6....6..7....5.4.......51..........57...6.93.8", + "62...8.3..9........1....5..3...9......4.....6...8.2.....953..848..9..31...64...2.", + "74...9...95.3.6.2....4.8..5......39.8......67..2...4..3...9.7.8.........5.....239", + "...91.2..1.63....43...7.5....3..2.9..5..4967.4.7....2.......3...........64....1..", + ".7...4..232..564.11..2...7................6..46.....3...81....5......2..2.64.37..", + "8..5.......3..1...59176....1..23.......9.58.79.76......3.8.2..6..6.7....2...5.9..", + "4...28.7...6..7..587.94...1...21.7......7.9.6..15...4.9...5...4.........5....9...", + "......9....57....8..69.35.73.2.48..6..4....9..8..3...42.9.........5.....8......29", + "......8...5.49...2.8.35.1.4.....9.7...217..........5....1........8..429...9..3..8", + ".2.......7.6.9....9....2.4...3...129.......36......7...417..2.5..74...9.23.....6.", + "..9.........2.14.8.........6.......3.85.63.....1.45.9......93...23..4....6.8..1.4", + "6.......4...18...598...4....5..7....8.495.1.7..6..8..25.1....26..7......24...7...", + "...5....9..1..2....4.8..56.......4......7.81...4.1.....5...69.82....46..81.7....2", + "9.2.7..58...2....1.81..9.23....1.........7.....4...13..49.81....385.....2.7..4..5", + ".4......52...........5...2938...6....5672..8.9..4.....4....38.....9....6..7.6.2..", + ".....3......18.3..4...79..8.73....4..18.27.........5...............4.1...415.893.", + "18..576.465....7....7...5..53...1...4....8.93.....3....741....8......9.186.....7.", + "....9...2..4.......2...6...3.1.64.7..82...1..4....29.3.7.......1.34....6..9831...", + "..5..6.3....1...98..1..976........598.....2..62..7....2.......1.7..3.......6...23", + "....78.9..9.1...4.1.8...6....26.........5.781.......5..4...68.....21.5..........9", + "....7...9....42..7..6..5...5.27...1..6...14...4.9.68.5.51..9...9.8.2.............", + "..594...78...534..6.2....5.7......464.6...329.3...........9....974...6.8..3...2.4", + "2....9.6.5..........1...3.534..5.....1.73..9.7.5.26.........75..9....1.3.......49", + "..8.5.9..75.......4.....23.91..7.8.2...........5482.....1..3...8..52......3891...", + "7.56.......1........4.2.1.3...46..2.6....8.7..1..3.4......72...8...1...2........4", + "...32...7....8......5...213....47......9..1.5.71...89..42.3.......5..7.........21", + "...2..5.....18...........1..1.7.2..95...3...6..7.9.18.8....7...7..92..6.65.....32", + "5........8.......7....79....9.......4.7.28..62..9.73....85...64.2..6.....4578.2.9", + "......8...9.3.....8.....4....37...2....9.2.1...9....7..3.2.59..7..13.....5.48...3", + ".9....2.5....9....1.......4.4.6.2.....71.4.6.8..9..1..2.....597....7..1.5.....4..", + ".1..78.4.85..2.7....65....1.......979.7.412...61........2.....8.....9......75....", + "7..41....2.........3...9....2.......34.76.2..6.7.95..39....3.2..6.12..4......61..", + "........75.....12..7..41..8....6..1.....728.4......75...76.....1.5..3.6..6.4....5", + "4....6...9....4..3..1..79.8.63.7.....9.3.871.......5....7.........59..........85.", + "9...7..4..42.163..3.6.9..2...3.215................47....5........736..9.......17.", + "..6...7.448........975.4..8..3......71.......6.....9.18.1..5.97....3.5...4.7...1.", + "...2.6...9.....2347..........8.35....3..7..59.......4.34........9.6..37..56.....2", + "54.....9..219....68..312....8.6..51.2.6.....9..4.5..3.9...6.....3....8..........5", + "..9.5...21.543.....239.....3.1.....5.......8....81..9...4.....6...6..23..6...8..4", + ".9......4.1...6....68739.2..3..2..........5...2.....1...324..8..7...1.3...26.....", + ".7..6...3.684....2.....8....2..93....3...75....9....8..876.9..........5.2.......4", + ".......9..9........3..15..6.126..58.6..1..........9.3........592...38...58.7...2.", + "2....8.67.3.217....8....3........7..5.....8.....5.4....4...3....2.6.158.7..8....1", + "1..4.......69.23...........2.4..571..79..14.6........24.7.5.19........35.5......4", + "7.....8..3.4..759...2.93.6..43.6.....6...5.3.8...4..........7.55....2.......78...", + ".....6.....92.4.....3...8.4...73..589......42...9..3....6...78.8...2..9.....796.5", + "793.....5....6.......3.1..8.3.1......57.....96.9....73......9..184.....6.76..5.8.", + "....3........2..6....698..1.8......3..6.1.52........1.1..2...844...6...92...49.3.", + "5..7.....86.5..4.3.......8.15.8.4...63........4..1.3..7..1...5........27......1.6", + "1..........8....6296...3.1...9...82.6.1..9.37.3........74.........9.4..88....6.71", + "9..5.1.2...39.....8....6..1..6.1..3..3.275.1.18..9.5.2............8...9......2..8", + ".9....8..7..3...........6.4.5.7...4...3..9...6.82.3....8.....73..6...48..3..4.5..", + "1.7.5.....3.......5...89.3........42.8..7......25.1....94..83..8..4..........21..", + "9......12135.2.8.......8..5.186..3....4.......2693....8....62........5.9.......6.", + "..57...6.9....4.....2.....4.972...1.46......5.5..41........6.73.1..7952.......1..", + ".....89..4........2.9.31......3....2.....4..1.1.58..9.3.1..62...9..4..8....2.9.5.", + "......18...6.....3..16.24.....8....5...536..8....74....1..8..7..38...561..4..3...", + "73...1.......3...45.2..................1...4...48..51...56.2..7.1..7348...85....6", + "..3...1..6..25..4.4..........2...........63......1.....4.62.85.5...812.37.......1", + "6..31.5.............3......5.916.7.316........7......59.18.2.....2....98.8.7...1.", + "...3...5..9...281...4...9.27...59...8....174.........89.2..7........3......428..3", + "1....3..5..2...3.4.3.48..178.1......37..2..58.....64....71.2........4............", + ".3..9.5....5..3.9..29..6.8.57.8......9.....7....5.....71.....6.....6....6...1.827", + "...1.52.8.2.4..16........4.1......2..423......3.....5...1.467....67..8...8.2.1..6", + ".....63..3.89..2.62.......4.7.4........6...35...57...2..3....5....7.8....24.....3", + ".3....5.....2....45194....8......6.2....9.....83.469......3.1......68.93...9.....", + "8...7.....7314......16.........2......291..43..94.86.77...6..1.21........34......", + "....9...2..............6.1.6.2..15....1..9....5.4.3.....46.279..9..3...413..4..5.", + "..5.1..6.92..5.4.1..38..5..582..36....49.............2.......8.3.14.......6..2...", + ".......67.3...1....2.........18.7.3....1.6.8..7..3964...92...13264..3..93....8...", + "4...63.......5.21..65..79......295.....7.1..2......4....71..62....634.........3.5", + "16....37.5.........83...2....2..516.....3...4..1......41.3...2.......6..3562..81.", + "..12..7.6..79......2.7.5.9.....6.54.4.5...8.26..8....1.....8...9.......4.....1.5.", + "..29...1.....15.377...2....42........8.....7.5........9.5..4.818...5.7.4.3..71.9.", + "1.3..4.7.....8...2.6..1..........5....4..3..6356.......82....3..7.......5...621.4", + "38.45..1..17....9...5.8.7...4.89.......716..9.....5....3.16..............51...8.7", + "....42.38.6.38........95..6......5.7649.......5..2.4.......67.3.........8.3..7.9.", + "...9.2.5....38.9..5...1..6.32...............1.7.......93.5....285...1.7...1..7..8", + "......6....5....7....296...52.93..1.......7...3..67.9...3.2.9.......5.81..168...2", + "....9..6......3...6.5......1..2..4...9..6..1..3...5..28......51.1..5.2......34.9.", + "2...9.....861.3..5.3........12..98....9.2....57.8.1.9.3....7....5...863........5.", + "8.49.27...7..8..4...6...28..5.4.......753.9......7863...2..4.............4...3.9.", + "5..1..9....8...1...9......33....1.9....6..8..1..3.56.4....685.......4.2..26.3....", + "2.4.8..6....6......6.235....3..615.4..89....6...8..............48..9.2..5.1...3..", + "..4.....3..35..8.....1....28....1.962.9.5..481....42..3...6.......9...1....2....5", + "67.4..32.....8..14..1.....9.8.3.2.....4.7.....3.81......3.69.4..4.....7......3...", + "4....1.57.3.6.....16..5...9..9....8...576.9.18......7.....95........4...7.38.....", + "........5642.......751......8.6.1..77..2..5.8....8..1.8..35.46......2.5...47.....", + "..79......1....2.7.....8....78..3..2.32..5..8.91...6...6..7.9.......6.1..2.8...5.", + "4.6..8.2...5.....77..9.3.469...............5......79...32.......8.5........4..832", + "274....9.......5.65....9...6......4.42.............18791...4..8...6....1.561.79..", + "4.6.3..9..219.6...3..14..6.....8.......613.4.......38951.2.....8..........48.....", + ".4.21..6.2.....94..7.4.9.587.46.5...8219......5........6...7..........8.9..5.....", + ".542...3....14.....3.6....9.7.3....2.....9..46.97...5.24....9..3...1.........6..5", + "..4......9.2.8.....6.3.78...73.....95..67.2..24.5.9......8......5..32..6329......", + "5.8.67..16..5.19....9.2....19.6..........4...475.....6.5.........1.78..52...1....", + ".1.........7...89.29..............177..28.6.5.3..1..2..6.3.....5.89....61..8.5...", + "..7.6258.....8..195..........32.9....8.5...3..5...6....3.......7...1..6.812......", + "1..6....3..9..52....24..8..2..8.....58..149.........1.4.........53...4.6.9.....2.", + ".2..4.5.....5.2...........7.8...........7621.....517..5.16...9826...........97...", + "..521....9...8.......5.4..22.1.......7.......3.47.1.9.8.7.2.3...9.1......4...9..8", + ".97.3.....8...........4...9....91.....5..2.91...3....82......7.7.35..94.8.47...5.", + ".531....4..6....9..24....6..8..35.1....2.693....48.2....564..2...9.5.............", + "9.1..6.......5...464...97....4...5...3....6.117....32..........4596.3....63...4..", + "..415...7.7....62.....24.8.7..9......9....5.8.5....76....6..8.2..6.......28....9.", + "...12.3.......5....8....7.1..52.....867......3...9..5.9..3..16..7.6....9..6....3.", + "..316..7.9....74...7.....68....75...65..8.....47.1.5.3...4.....1.....7....9......", + ".1.2.....9.3.61..5..2.....3.7..1..........4....9..5......7.6....45.936....1.5..7.", + "8..96...5.....1.3.132...69.6...123..3.1.5...4.....95....42..1..2....8............", + "..........437...1.561......675419.3..........4.9......79...14.6....6...81..85..7.", + "..4.9....28...6.....6.3.....3.8....94...138...2....34.6........513...6....9.42...", + "31................8...63...2..7.5.83.......4.13...46......5.4....3.1..72.7.8...51", + ".641.....19.37.6..3.8.......56...1..7...9.....4......7...96.4.5...5...78.8..3....", + "9....1..4.............5...9.89.....65...28.......3..51..15.42..3...8..9.....631..", + "....9....5..3..61.4.165......2.3.16.7.......5...1.7..9.4.5.37.2......5.....72....", + "1.87.92....5........324.57....9.1.8.3..8.4..72.....1.....5.2.......37......4...5.", + "..6598.........5.9...........8.6....6.19.5..8....21.3..9.1..2..23..5...6..7..2...", + ".2..13.4.3...4571....9..3.2.46.5.........2.....5..1....5...7..94..52....7.9.....3", + "..1.......5...23..8..436......69.1.......8.96.2.1....531.8.4..9985.2.............", + "..2...8.4...9.47....6.5793.83.....6......5..87....2....6.4....7.4.3.....3........", + "5..8..........6..26.84127.........6.274...........81..1......5.8..354.....2...8..", + "6..1.7....8.......1.4.68.........78..9.....2.23..7.61..4....3....9.8....81792....", + "..2.41.9..843........5.9.....3.....7.4..7..298.....4.5...9.28..2..837.......5....", + ".....68..9....32....3.2.79..5..6..7..81.........91...6.....53.1.1........2.6...5.", + "5......371..56....48..73...9..8..6.5..1....7.....1.9.....3.....6..1.8.4......4.5.", + ".3.........2..9......168......3.....1...2...6..6.....7...87..248...1..6..43...19.", + "2...65..7.6.3.1..4....7.1.2.3.......4.5........2...91.926...47.3....9....71......", + "..2...7.9375.1..2.........5..76...8.....916..2..73...........671.....29..6.2..13.", + ".....1...5.64.9..1.34.....5..7......81.7..3..3.9......7...96.58.....7....6.5.87..", + "........9......36...5.8.2.15.2.4.....19.2..56.68..3..........2...4.5...8....1.93.", + "...8...72....728......9..4....1.........4...7..7..816.32....6....1629..3.....1.8.", + "...4...7.3...7...11.83....97......3.......6......6..18..1..8.93..9..4.8.6....9.5.", + "..89.5.....24.1.5....68...4.6..3..4.8..5..1..4.1..9..8.95.............6.31.......", + "5...23.1...3..........64.7..6....2.1.38....672..45.83....2..........5....261.7...", + "..865..47...4.721...........629....5.4.......59.7....278..........2.95....15.....", + "..7..26....2.....8.5.6.8.32.132.4...7..5.....58.31...........56....31...........4", + "..9...8........7..54.7....29.786..1.8.....9...6........7415.68.65...2.74.........", + "8.467.....7.5.8.366.59..........3..84....91.........93.1.7...89.......5...63.....", + ".91....8.....6.3.1.26.91.4.7.431.............8.....1.7...........9.7.8...4...963.", + ".6..7...4.....4..17..69.....8..2....4.79..3...3.4.6..92..1...9...12.7.....8.....3", + ".9..........5.1...1....83.6..1....5...4..3..8.6..2.1...5.4..8...4..125..6..9..2..", + ".81......23....4.....4......4....1......3..9.1.8..9..2..9....363....721..6..1.7..", + "89...71..............95.84...4...519........6..8...4..4.5......98.1.67..67...439.", + ".....15..1.872..3....6...7...2.1.....4......5.3...81.4.87......4...7.....2..5.6..", + "3.....61..8..6...71.6379....3.7.8........48..........224..97.8......3....9..8.43.", + ".5..3....1.7...83.6.........1.....4.463............5.7....57..2..4.2..6..7..46..3", + "......68......23..867..32....9.............18.3....765..3..8...1.8....927..5.9...", + ".3.1.98.4..5.436...6......19..7..4.........67....38...3....1....5.3.6.9.....5....", + ".1..692.7.5.........8..76.3.8.712.......8......5..6...2.....16..9..2...8.3.......", + "782.5....6.........5.1..3......42..75..3.761.8....5.4........7..........2.1...45.", + "68.59....7.......89....2.54.25...........15...6..4...1...8...62....2.74...7....1.", + "4.7....8...2...3..85.43...957.29.....2..4...7...5..2...8.....7.6..9.......4...85.", + "..2.19.....56......6.387..26.......3..7...526.......1...325..9.7..9.8.......6....", + "......15...9.253.6.....79..........5..7..4...2...5......3.....75..9..42..9.41..6.", + "..61......8...7.3...4.3..758....6..........1...342...8.....8....17.63...43...5...", + "............53...9..9..1.5..6..9521..7..265..8.............819....6...8......7.36", + "...2...4......38....6.5.3.98.5.4793..43.......9.....27.32.....84.....59..7.......", + ".7.4.3.......62...6..71.....61.4.5....2.5.......6.14...1.52...3.3....6..74.9..2.1", + ".4....6.3.15....4.39........56.48.39....5..1...3....8......3.955.4...86..79......", + "6......7.5....81.....7.64.......36.1..18.473....6.28.5.........254.......83..7...", + "8.172......6.9.....2..8...7...5..7.....918.....8.4.61....1...29..7....51.9...4...", + ".687..4.......9.3.925....872.4.8..56.9..63...6...........4.....4......6.58......2", + ".5..1..342...6.58.9.....1..3..259..8...1.........839..5....23..........1...53.6..", + "1.69........6.1..7.....4...3..5.74..4....9...879.6..1.98.....5...43........845.6.", + ".3......2..5..4..8.746.35........7.6.6.4...232...9.45.....5.....9..........2..8..", + "....7...3.7..9..2..9....6..8.4.....9....62..1..13....7......7.29..42.186.1...8...", + "...........7...2....8...4.62.........76.49.....432.9.8...2...6.64..1.8.9..38...42", + ".3..216.....46......9.73....1...2.........4...94...72..52..4....6....3.7..1.....4", + "641..............78.2..4.6..579..........2...4....1...72..1.9.61...9.......4.8.15", + ".1...3...459.2...183..5...2..5....4..9....38.1..9......4...56.3...26...........54", + "1..5..9.......8.14........56.4.........1......8..457...68.........63..9.95...137.", + "1.37....4...4.9..1.....5...4.......2...9....7..7..3........7.5..1.3.6..992.15..73", + "8.3...7.97.........9.....1897...6..2.3............1.572.879.5..........1.....3.8.", + "96.32415.....9....3....1.26.......8..3...56.4.4..8..95.....8.398..53...1.......6.", + ".2..........4..7........8....78.4..1.1.92..34.5.3......392..17.8.........7...84.2", + ".5.23.......6..8....8...5.....1......39.6.....4....9...8....4.33.....62.2..45.19.", + "..71..5....98.6..4.51..498...5.4.......5..7...4...1..3398.7...................4..", + ".7.6...38.34.2..5.1...87.2.4.7...6....3..2.8...6.4...7....368......782...........", + "73...5.2..1...84.............3......6.....2..1.4..2.5.87.....3......1.45..67...8.", + ".2..7..5137.8.12.4.5.42....8..5...72...2.........3..4.........5.1.....3.....836.7", + ".....52172....9.5........4.59........42.........8.2......9..174..54.8.....76....8", + "38...2...1.6.5..7.....3.8.92..1...5..1.8...62.5...6....9..2.7.............73.....", + ".......5....182..4....46..2...91....32...4.8.64.............2....83...69....91..8", + ".5.......3..765....8.2..4.15..........36........1...87...3....2..6.7.14....42.76.", + "1..5.27.......76.94....31...4..9.....154.....2....5...69.......7...56....217..4..", + "...5.372....84.3...31........472..8...54.........89...92.....5.....9714.......23.", + "...6...7........1..34........85.4...1..7.3...97..614....13..86..5.....9..6..8.7..", + "..34..8...8...6...2..7..3...4.9..6...72.4....631.....4.....8726.2.....41.........", + "2..3.514.61..2.....3.78.........48.3.2......5...25.47.5...4....7......12......68.", + "2.4......9.1..827.7..5..8.......7...........56...9....1.7..9.....8..4.9..6.2..1..", + "..4...5.....48..1.1...2.7.3.48..5...2...1.35.........2............6.8...3..15.46.", + "......3.4..9....8..4....51.72.......3......9..817.......79.84..29..34.57..52...3.", + "7......8..3.....1..65....3.4.3..5.9.19....5...7............6...8..7.49....7.3.14.", + "2........87..2.9...3.9........2..4..3...1..86.92..67.3..4......9274.8.6..8.......", + ".6.........9.758....1.......2.6.1.459..4..2.....85....6..5.8.....5..918.8......7.", + "..31....278......41.9.......1.....73.46....8......2.6.2.4..6........96...3...4..7", + "..56.....8....1...7...8.......9.85..12...5..7..7...8..2..5.619.4...........2..65.", + ".9.......7.8.3....36.9.....6..72...9...1..58....5....32...5...1.7..6..3.5...7...6", + "23...48757.5.....2.........4..2..5..9.34.8..66......8........54.92...6..86.....9.", + ".1.........9...2.8...5.471...43....9.8....3252..............15..432.5.8..7...1...", + ".3.....9....7.....2..8....7.6.9............35..2.65......23754.....5.3..8..6...7.", + "..51....94...5.1..2.36..4......6.....48...9........821..1.3..9..82.....46...1.2..", + ".1..52.9...536.....931...7....21.9...8.......7..6......59...6.......3...........2", + "....8..9..74....3.9.3.......1...3........9.....987.24.4.8....1..2.51......59..723", + "..83.4.1...2....7......18.....168....86.....3......2..69..1.4.....4.3......9...82", + "...3.6...6.7..9.....97......7..8...2..36....99.4..78.....5...2..5.....372.8......", + "..8....7.36......81..3.6..........34.3.1.97...85..7.....645........18.4.7........", + ".4........3...1.5.8.2.9.1..2...15.6.59.3..81.41.2....3.....4..9...953............", + "4...583..6........89.43....1.89..6.3.....5....4..637.55.7.89.....9.......6.7.....", + "5......2.....9..8....3........9.6.7...758......9.3.5181.5.7..9..76......8....2..1", + "9.....2.........3......9..4..8143...4..2....52....8...5..43.....2..5..1.17.....8.", + "6......21.41..25.3....9.7.............5..741.......63...2.3..469........3.74.6.52", + "..8....56...25..7...3.69.1.1...9.........376..37..........1.....94.2.....5.6...8.", + "...8.1.24.7.9346............2...6....3...27.....14..6...8....3...........92.6..48", + ".6...4.....4..368......9.3...8.1.....9...2...43....81..23..6.9.54.......6..29....", + "..89...5.7.1..2.......7....379..4....4.3.......2.59....1.....4.2.7..83.9.3.2.7...", + ".5.6..23...98.....21..9....4.52...6....9......21.8....8.6..4..........45........1", + ".....9....5..6.4.....7.......8.4..76...93...1.9...154......4..5..159.6.4..5.7.18.", + ".........3.9.....4...796....63......18...49..95..8...14.71...3.5.....4.8...3.9...", + "............38...17...168.99.........5.19..7.84..3......68..7......5.6..3....95..", + "....5.......8..71.5..23.........1..9.25...8....7........392...7..1....5..8....926", + ".....2..8.3...76..8..15..2.74....8....1...23.2...75.6.1..........7.3..5..6.......", + "6......9.....3.58.75.......3.89.4..6.7...3......17...4.9....1..5..6..7.88.6......", + ".......81.........14....2..9...21...8..7...5347..3.......5.4.3..2...9...3.5.7..1.", + "3.4.9.....6.5...8..98..7...5....167.....345...3......8..7.8.........64....5....6.", + ".2............68...1..39.5..3..5.6.........315.......9....63.8.4..5....6..94..2..", + "..6......53..........954.......657...98...6....781...4.......573...7........83.9.", + "3....8.......9.....71.24..58.7.52.9.2..8.........47.2351..........9.3....8..1..4.", + ".7.......419.....76....84......9......13.482.3.26..9..836.41...1..2.6............", + "......6...4............9852..5.3...8..4.96..13.2.5..4...6..42.9.3.....8.8.9......", + ".......6..6...2...2....5.......6....8..4.7...6.4.2.59.5.......3.8..9.4..7..84..2.", + ".........7.....9....92....4.4.13.....16..87.......7.2....9.1..86...7.2.39.43.....", + ".537.6..........59..624......9.6.84...2.....7...8.7.9......9..3.....846....65...8", + ".275........16..4.4....2..9......9.7..59...12........46..2.....5..4.9.6....7..8.5", + ".3..2..8......4...8..61..7.69..8....7.8...2...1.....38..1...9..9.6.3..4.4...72...", + ".472.....8.5.69...2..5.....3..7...4.......25...6...9...9..4.7...3.8.5..4..8.....2", + "34...5.911984...766.5...4.8...6....59...58.....31.4.......3.......5.6...4.19.....", + "...97.....3..1....718..4.....4.5......6..8....8.1...356..3..97..93..........8.4..", + "..5..7.......842.7.2....4...9....6.....42....1.7..9.2.5.4.6..1...1........2.98...", + ".....6.497.....61..5.......3..9...652.....7...71......5.....1.44327.........95.3.", + ".2...4.....8.7.63.9..2....4.....9.5.......2.6...68..4...2...9.3.36.....7.....5...", + "..........9.1....8.....65.....9.8..2.71...9.....2..6..1..7...5...8..4..676..592..", + "..2.....7....4..81.........3.....8696....74...243..7...194...32...72.9.4.....6...", + "3..89.627..87....3.............3..8.6...7.1..2.398...5.......6.9..62......1...9..", + "...1..9.88..2.6..4.......6..5.......9.....72...4.2...5..5...17..92......1...54...", + "........81..6.7.3....341.2.93.....167.193..4.8....2..3.....6.....849....4...18...", + "...5.87...53....1......7..66.1..5..2.329.1.....8.2..5..8......3...6......2....67.", + "8.7.6..9...2.3...6....17.8.316..87.2......9.8...2...1...5......7.......3.....6..7", + "1.7.5..29..4......5..6.2.......7...4...1...9........57.1.54..7.4.9...8...5..2..6.", + "...6...8....1.8.7.....32.....8.7315.1.4.2..........2..75.....4.6.2....1....715..6", + "3.1...25...45..1..92...63....8.4....2.......1.9....6......84.2.....15.....932.4..", + "..573...1....4.6..........96...7.4.5.....9136..........86..4...5..1.....94.3.5..8", + "9...6........15...715.......9.1485..6...9..........8..4.6....75.2..561.9.....4..8", + ".......2.......3...2....78.87.9.4..1..1..2..8.3..5.97....4795...1...84..7.......3", + "....6.43.....5.......1.3...4.1.7..2..37........284..7..2...68.416..8.5.3...5....2", + "....23.7..39...5..2..49.6..46..7.9...2....3.7..8.......96..24..7........5...69...", + "....4852......2..4..7.3....56.....4.7..95......9.....7..63.....92...67..458.7....", + "..6..2..5......4....4..5.96.8.7...63.3..2.95...7.6..2................2.9...3.6..8", + "....6...787.4.3..9.43...5.....3.58.4......73.....4...27..8..6..........5..267...3", + "5...2...86........972..64..4...1.8..76.5.9.4.1.9..8..5......1.6...1...5....4..7..", + "45.3...6.1....9..3..7.........73..4....5846.....9.6..15..61.9...7........83......", + "..9.87.516..91.........2...3.1....9.9......758.2..51......23.....3.7.2.8........9", + "5...3.49.8..4.56...3...9..1.....3.............5...1.32..39...6.48.6....5......8..", + "4...25.1.7...49..2.............61.4.9...74.6...79...........9....2..73.4...23.1..", + "...6.2.....4.5.7.22..7..8.97.2....4.3.....6...95.......69....844...9.3...8..6....", + "..69.7.4..2.3.1...8..62.9........8...4......3.7...9..24...78.2..8....7.63........", + "71..3..68.....6..2..3....4982.4...1....1...83...27.....41..2.....7.....438.......", + "...4...6...23....4.9..2.1.32.7.9.....69......18...32..72........16...9....4.6...8", + "1...4..255....9..88..31.....4...3.......8..92.7..54...4....1.....9...8.1.......57", + ".3.......5...1....91758.4...2..34...4......92..52..14....97.8..8.......5.9.3.....", + ".36...21.528....63....3.........8.9....976.....3.2...76..7....2....19.5....8...3.", + "72...5.....1...96...3.....86.5.18.9..12.....7.......5..6.....3..971....6.....2.8.", + "..9....8....73.........47....3.......8..1.....4..9317.....423...6.87.4.9.....6.1.", + ".8.6.....1...4....763...1............1...75.4576.9......7..4.9.....38....4.7...83", + ".6...2...5......24..2.58.....7.2....4593..7.....54.3......64.7....93.....36.....8", + "....4.5....8.3.....53.9.4.8...76.3...17....9...58........6.397...........7..85134", + "......8...4..2.6.9...6...3...7..31848.......3......7...2...6.....4....9.9.61.83..", + "...86.217.3.9.........5.8....5..197..8..2.....2.3.56..5.....7........19...3..9.5.", + ".1.957...5.9864..............6.2......84952.....7..4.....5....4.41.89...7....269.", + "..........1.3..7...3..46....58....6...9..54.11.3..7.8....4...79.967...1.4...8.6..", + ".....69......7....3.72...5......4....3.8....6...9.2.357....9....49.2.78.85.4.....", + "64.9...7...8......93..24.8..1..7..4..9......6....4.........2..4.2..1..3...638....", + "..47.3.5...........2.6...83........6.5.13...4...82....3...5.1..28.3..4.7.71.....2", + ".897....651..68.3...2...8....3.1..62.2...57.....37..8....28........36...6..5.1...", + "5....2..........2..6...7..1......25...7.3...4.5.2843.....56.83...1..3..7....4.1..", + "16.......2.8.6.......8...4...4.3.85..3..5...2...41...3.5.1.....672.........5...8.", + ".4...9.7.......4233.7......5..8.....9..5.6.872...4.3...95...8.26.........8.4...96", + "8....2.16..6...3...4.....8..3.......9.2.....8..5..9..32.3.8.1.....5...6.51....9..", + "79..4.1..8.3.7..466.453.9......5......6...8......9.753......58......4......78.69.", + ".....6.4..4.72........35..2....8.29.....72..85..6...3...9...87.6...57..4...3..9.6", + ".1....6.4.....1...3.84.......1..2.594.3..5..25...6....6..8.9......253.4.....14.9.", + "....2.75....8.1.6.5..6.........781.......6.2..2.....3...7.....43.6...87......4..5", + "71........29......5.......3.....178......34...4...72..9......7.48.2.......3.19..2", + "8....193...523....9.2.....756...8...........1.9.....6.1..9.2.8......65....7..5...", + "7.65.1....8...7...2.5........24..19.4.....8.6.9.67.5.....8.........56..21...92...", + "...3.......5....87.3.8.7..2..64...15.5..312.62...7...4.....8.5.4.8.6..2.....1....", + "9..7.5.....6.9....18....9.....9.....7...41..84536......3..84..7.......1...4...8..", + "7.12....5.89......25.9...4.4...2.1...7.8.9......46..725..6...2.......9.7.2....5.4", + "..58..7.973.......9.....12.4.3.......78....4..1...........3.8...5.28.97..9..14..5", + "....4368....1..2.4....79..3.9.3.4...............6..921...7.....97...1.3..21.6....", + "1.54..93.2.7...5...94........2.53.......6.157...9............7...9.......6..2..41", + "7.6.5..8..9...6...5...2.....7.1.....85.....2.4....9....4.5..1...1...7.95...4..8..", + "...4.1.....46..19....95.....2..4...6416....3.9.3......3..57..6..51.....77...1..4.", + "196.7........2.9.......47.56.58...2......16.88...47..1..4......7.....8...2.......", + ".3..7.............7...32.8...3.98.655.6....2.8..1....3...9...5...7...2...9...6738", + "2....7..9.3.49..624...3.1....5.....1.2...5.7............36...5..6.......51.9..3..", + "..8...3.1.3.....5.1.6.2...97.5.1..2.3..2.....2..8..57...2...7.....9.8..........18", + "..9.672.....4....1....92....6.2..91...89.1.43........82.....8..4..62.....31......", + ".2..9.81.96...1..2...5....9........5.9.8........2.3....7.....5335..7.19...63...7.", + "5..4.........6..9.286.1.........971..27.5...88.1...4........6..9.....8...15..7...", + "2.9.............9..165....71.....7..4..9.2.15.321..6..94...7.......3....67...5..2", + ".836....449...8.......3................4....81529......6..23....3..6921..15....3.", + "........59...3.2..1.....6.3..9......2....8.464....29....49.....8..1....236.524...", + ".9...6......48.......132.6..2891.5..36....9.1....2.3........6.3.....4.9.6..3..418", + "..12....5.94................3.5...8.948...........2.9..1...3..6.651...4....8.9.2.", + "..5..9...9...5...7.4......6......5..8.2....9.5...42..1.61...8....89...754...6....", + "41........7.1........25.....6..4.2.15....2.36...5...47..6......129.36.7.7.......4", + "3.....59..1.9..6.2..23...71.975..2.....4......2...6...1.........6.7.5..4.7..32...", + ".........2..16.....68..7.....7....6..8.623..15...8..9...3.......9.51...81.5.9....", + "7.82..6..9.6.4.....1465........6.5....1.....2......19...2.94.5.1.582.7.9.4..7....", + ".65127..8..1....52....3.67..........3.4.5.8....7483....5.........83..4.....86...7" + }; +} diff --git a/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/package.bluej b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/package.bluej new file mode 100644 index 0000000..5fcb5a2 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/01_sudoku_roh/package.bluej @@ -0,0 +1,124 @@ +#BlueJ package file +dependency1.from=BekannteZahl +dependency1.to=SudokuPanel +dependency1.type=UsesDependency +dependency10.from=SudokuGitter +dependency10.to=BekannteZahl +dependency10.type=UsesDependency +dependency11.from=SudokuGitter +dependency11.to=Kandidatenmenge +dependency11.type=UsesDependency +dependency12.from=SudokuGitter +dependency12.to=SudokuRaetselDB +dependency12.type=UsesDependency +dependency2.from=Kandidatenmenge +dependency2.to=SudokuPanel +dependency2.type=UsesDependency +dependency3.from=SudokuFrame +dependency3.to=SudokuGitter +dependency3.type=UsesDependency +dependency4.from=SudokuFrame +dependency4.to=SudokuPanel +dependency4.type=UsesDependency +dependency5.from=SudokuFrame +dependency5.to=Kandidatenmenge +dependency5.type=UsesDependency +dependency6.from=SudokuPanel +dependency6.to=SudokuGitter +dependency6.type=UsesDependency +dependency7.from=SudokuPanel +dependency7.to=Eintrag +dependency7.type=UsesDependency +dependency8.from=SudokuGitter +dependency8.to=SudokuFrame +dependency8.type=UsesDependency +dependency9.from=SudokuGitter +dependency9.to=Eintrag +dependency9.type=UsesDependency +editor.fx.0.height=940 +editor.fx.0.width=840 +editor.fx.0.x=24 +editor.fx.0.y=26 +objectbench.height=137 +objectbench.width=814 +package.divider.horizontal=0.6 +package.divider.vertical=0.7974683544303798 +package.editor.height=547 +package.editor.width=703 +package.editor.x=638 +package.editor.y=53 +package.frame.height=811 +package.frame.width=854 +package.numDependencies=12 +package.numTargets=9 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Eintrag +target1.showInterface=false +target1.type=InterfaceTarget +target1.width=80 +target1.x=270 +target1.y=320 +target2.height=50 +target2.name=Kandidatenmenge +target2.showInterface=false +target2.type=ClassTarget +target2.width=140 +target2.x=160 +target2.y=440 +target3.height=50 +target3.name=SudokuGitter +target3.showInterface=false +target3.type=ClassTarget +target3.width=110 +target3.x=480 +target3.y=260 +target4.height=50 +target4.name=Set +target4.showInterface=false +target4.type=AbstractTarget +target4.width=80 +target4.x=20 +target4.y=310 +target5.height=50 +target5.name=SudokuFrame +target5.showInterface=false +target5.type=ClassTarget +target5.width=110 +target5.x=330 +target5.y=50 +target6.height=50 +target6.name=SudokuRaetselDB +target6.showInterface=false +target6.type=ClassTarget +target6.width=130 +target6.x=560 +target6.y=150 +target7.height=50 +target7.name=SudokuPanel +target7.showInterface=false +target7.type=ClassTarget +target7.width=110 +target7.x=40 +target7.y=120 +target8.height=50 +target8.name=BekannteZahl +target8.showInterface=false +target8.type=ClassTarget +target8.width=110 +target8.x=370 +target8.y=440 +target9.height=50 +target9.name=BitSet +target9.showInterface=false +target9.type=ClassTarget +target9.width=80 +target9.x=20 +target9.y=390 diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/BekannteZahl.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/BekannteZahl.java new file mode 100644 index 0000000..8c573dc --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/BekannteZahl.java @@ -0,0 +1,59 @@ +import java.awt.*; + +/** + * Repräsentiert eine "sicher" eingetragene Zahl in einer Sudoku-Zelle + * Kann eine Vorgabe sein oder eine durch Schlussfolgerungen gesetzte Zahl sein. + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class BekannteZahl implements Eintrag +{ + /** + * Der Wert der bekannten Zahl + */ + private int wert; + + /** + * Die Farbe, in der die Zahl gezeichnet werden soll (für Backtracking-Situationen) + */ + private Color farbe; + + /** + * Erzeugt eine neue bekannte Zahl + * @param w Der Wert der Zahl + */ + public BekannteZahl(int w) + { + wert = w; + farbe = Color.BLACK; + } + + /** + * Markiert die Zahl, dies bedeutet, dass sie beim Backtracking "geraten" wurde + */ + public void setMarkiert() + { + farbe = new Color(140, 70, 120); + } + + /** + * Zeichnet die Zahl auf ein Graphics-Objekt + * Sollte nicht direkt aufgerufen werden. + */ + public void zeichneDich(Graphics g, Rectangle r) + { + g.setColor(farbe); + g.setFont(g.getFont().deriveFont(65.0f)); + SudokuPanel.drawCenteredString(g, ""+wert, r); + } + + /** + * Gibt den Zahlwert der bekannten Zahl zurück + * @return Der Wert der Zahl + */ + public int getZahl() + { + return wert; + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/BitSet.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/BitSet.java new file mode 100644 index 0000000..2f8bf0a --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/BitSet.java @@ -0,0 +1,294 @@ +import java.util.ArrayList; + +/** + * Eine Set basierend auf Bitvektoren + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ +public class BitSet extends Set +{ + private ArrayList daten; + + /** + * Erzeugt eine neue leere Set + */ + public BitSet() + { + daten = new ArrayList(); + } + + protected int[] alsArray() + { + int[] ergebnis = new int[anzahl()]; + int index = 0; + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i)) + { + ergebnis[index] = i; + index++; + } + } + return ergebnis; + } + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public boolean istLeer() + { + for (int v : daten) + { + if (v != 0) + { + return false; + } + } + return true; + } + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public boolean enthaelt(int x) + { + if (x >= 32*daten.size() || x < 0) + { + return false; + } + int i = x / 32; + int j = x % 32; + int mask = 1 << j; + return (daten.get(i) & mask) != 0; + } + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public int anzahl() + { + int laenge = 0; + for (int i : daten) + { + laenge += Integer.bitCount(i); + } + return laenge; + } + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public Set differenz(Set s) + { + BitSet ergebnis = new BitSet(); + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & ~(bs.daten.get(i))); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public void einfuegen(int x) + { + if (x >= 0) + { + int i = x / 32; + daten.ensureCapacity(i+1); + while(i >= daten.size()) + { + daten.add(0); + } + int j = x % 32; + int mask = 1 << j; + daten.set(i, daten.get(i) | mask); + } + } + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public boolean untermenge(Set s) + { + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + int a = daten.get(i); + int b = bs.daten.get(i); + if ((a & ~b) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && !s.enthaelt(i)) + { + return false; + } + } + return true; + } + } + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public Set vereinigungsmenge(Set s) + { + BitSet ergebnis = new BitSet(); + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) | bs.daten.get(i)); + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + ergebnis.daten.add(bs.daten.get(i)); + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + ergebnis.daten.add(daten.get(i)); + } + } + else + { + int[] a = s.alsArray(); + ergebnis.daten.addAll(daten); + for (int n : a) + { + ergebnis.einfuegen(n); + } + } + return ergebnis; + } + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert. + */ + public Set schnittmenge(Set s) + { + BitSet ergebnis = new BitSet(); + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + ergebnis.daten.add(daten.get(i) & bs.daten.get(i)); + } + } + else + { + for (int i = 0; i < 32*daten.size(); i++) + { + if (enthaelt(i) && s.enthaelt(i)) + { + ergebnis.einfuegen(i); + } + } + } + return ergebnis; + } + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public void entfernen(int x) + { + if (x < 32*daten.size() && x >= 0) + { + int i = x / 32; + int j = x % 32; + int mask = ~(1 << j); + daten.set(i, daten.get(i) & mask); + } + } + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + if (s instanceof BitSet) + { + BitSet bs = (BitSet)s; + for (int i = 0; i < Math.min(daten.size(), bs.daten.size()); i++) + { + if (daten.get(i) != bs.daten.get(i)) + { + return false; + } + } + for (int i = daten.size(); i < bs.daten.size(); i++) + { + if (bs.daten.get(i) != 0) + { + return false; + } + } + for (int i = bs.daten.size(); i < daten.size(); i++) + { + if (daten.get(i) != 0) + { + return false; + } + } + return true; + } + else + { + return super.gleich(s); + } + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Eintrag.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Eintrag.java new file mode 100644 index 0000000..41959af --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Eintrag.java @@ -0,0 +1,16 @@ +import java.awt.*; + +/** + * Ein Eintrag in einer Sudoku-Zelle, kann entweder eine feststehende Zahl sein oder eine Menge von Kandidaten + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public interface Eintrag +{ + /** + * Zeichnet den Eintrag auf ein Graphics-Objekt + * Sollte nicht direkt aufgerufen werden. + */ + void zeichneDich(Graphics g, Rectangle ziel); +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Kandidatenmenge.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Kandidatenmenge.java new file mode 100644 index 0000000..5305d01 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Kandidatenmenge.java @@ -0,0 +1,56 @@ +import java.awt.*; + +/** + * Repräsentiert eine Kandidatenmenge für eine Sudoku-Zelle + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class Kandidatenmenge extends BitSet implements Eintrag +{ + /** + * Erzeugt eine neue Kandidatenmenge bestehend aus den Zahlen von 1 bis 9 + */ + public Kandidatenmenge() + { + for (int i = 1; i <= 9; i++) + { + this.einfuegen(i); + } + } + + /** + * Zeichnet die Kandidatenmenge auf ein Graphics-Objekt + * Sollte nicht direkt aufgerufen werden. + */ + public void zeichneDich(Graphics g, Rectangle r) + { + if (istLeer()) + { + g.setColor(Color.RED); + ((Graphics2D)g).setStroke(new BasicStroke(3)); + g.drawLine(r.x,r.y,r.x+r.width, r.y+r.height); + g.drawLine(r.x,r.y+r.height,r.x+r.width, r.y); + } + else + { + g.setColor(Color.BLUE); + g.setFont(g.getFont().deriveFont(20.0f)); + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 3; j++) + { + int n = 3*j+i+1; + if (enthaelt(n)) + { + int x = (int)(r.getX()+i*r.getWidth()/3); + int y = (int)(r.getY()+j*r.getHeight()/3); + int w = (int)(r.getWidth()/3); + int h = (int)(r.getHeight()/3); + SudokuPanel.drawCenteredString(g, ""+n, x, y, w, h); + } + } + } + } + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/README.TXT b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/README.TXT new file mode 100644 index 0000000..b1e254d --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Sudoku +PROJEKTZWECK: Implementieren Sie einen Teil eines Sudoku-Löser +VERSION oder DATUM: Dezember 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ SudokuGitter, entweder ohne Parameter oder mit einem int-Parameter (von 0 bis 399) +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Set.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Set.java new file mode 100644 index 0000000..60ec0f2 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/Set.java @@ -0,0 +1,107 @@ +/** + * Schnittstelle des ADTs Set + * + * @author Rainer Helfrich + * @version 26.9.2020 + */ + +public abstract class Set +{ + /** + * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist. + * @param wert Der einzufügende Wert + */ + public abstract void einfuegen(int wert); + + /** + * Entfernt einen Wert aus der Menge, falls er enthalten ist. + * @param wert Der zu entfernende Wert + */ + public abstract void entfernen(int wert); + + /** + * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist. + * @param wert Der zu suchende Wert + */ + public abstract boolean enthaelt(int wert); + + /** + * Bestimmt die Schnittmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll + * @return Eine neue Set, die die Schnittmenge der beiden Mengen repräsentiert. + */ + public abstract Set schnittmenge(Set s); + + /** + * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s. + * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll + * @return Eine neue Set, die die Vereinigungsmenge der beiden Mengen repräsentiert. + */ + public abstract Set vereinigungsmenge(Set s); + + /** + * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist. + * @param s Die Menge, die geprüft werden soll. + * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst + */ + public abstract boolean untermenge(Set s); + + /** + * Bestimmt die Differenzmenge der Menge selbst und der Menge s. + * @param s Die Menge, die von dieser Menge abgezogen werden soll. + * @return Eine neue Set, die alle Elemente dieser Menge enthält, die nicht in s enthalten sind. + */ + public abstract Set differenz(Set s); + + /** + * Gibt die Mächtigkeit der Menge zurück + * @return Die Anzahl der Elemente in der Menge + */ + public abstract int anzahl(); + + /** + * Gibt zurück, ob die Menge kein Element enthält + * @return true, wenn die Menge leer ist; false sonst + */ + public abstract boolean istLeer(); + + protected abstract int[] alsArray(); + + /** + * Gibt zurück, ob diese Menge und s die gleichen Elemente enthalten + * @param s Die zu überprüfende Menge + * @return true, wenn beide Mengen die gleichen Elemente enthalten; false sonst + */ + public boolean gleich(Set s) + { + return untermenge(s) && s.untermenge(this); + } + + /** + * Gibt die String-Darstellung der Menge (aufzählende Darstellung) zurück + * @return Ein String, der alle Elemente der Menge aufzählt. + */ + @Override + public String toString() + { + if (istLeer()) + { + return "{ }"; + } + StringBuilder sb = new StringBuilder(); + for(int v : alsArray()) + { + if (sb.length() == 0) + { + sb.append("{ "); + } + else + { + sb.append(", "); + } + sb.append(v); + } + sb.append(" }"); + return sb.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuFrame.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuFrame.java new file mode 100644 index 0000000..8473207 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuFrame.java @@ -0,0 +1,194 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +import java.util.concurrent.atomic.AtomicBoolean; + +/** + * + * Ein Fenster, um das Sudoku-Spiel darzustellen + * Hier sollte nichts verändert werden. + * @version Dezember 2020 + * @author Rainer Helfrich + */ + +public class SudokuFrame extends JFrame { + + Point backtrackingPosition; + int nextBacktrackIndex; + JButton btnBacktrack; + SudokuGitter dasSpiel; + JLabel lblSackgasse; + + public SudokuFrame(SudokuGitter sp, SudokuFrame parent) { + + super(); + backtrackingPosition = null; + dasSpiel = sp; + nextBacktrackIndex = -1; + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 800; + int frameHeight = 900; + setSize(frameWidth, frameHeight); + + if (parent != null) + { + parent.setEnabled(false); + setLocation(parent.getX() + 20, parent.getY() + 20); + } + else + { + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + } + setTitle("Sudokus lösen"); + setResizable(false); + Container cp = getContentPane(); + cp.setLayout(null); + + SudokuPanel sudokuPanel1 = new SudokuPanel(sp); + sudokuPanel1.setBounds(8, 8, 720, 720); + cp.add(sudokuPanel1); + + final JLabel lblGewonnen = new JLabel("Spiel gelöst"); + lblGewonnen.setBounds(220, 770, 400, 16); + lblGewonnen.hide(); + cp.add(lblGewonnen); + + lblSackgasse = new JLabel("Spiel so nicht lösbar -> Backtracking nötig"); + lblSackgasse.setBounds(220, 770, 400, 16); + lblSackgasse.setForeground(Color.RED); + lblSackgasse.hide(); + cp.add(lblSackgasse); + + final JButton btnKandidatenListe = new JButton("Kandidatenmengen erstellen"); + final JButton btnEintrag = new JButton("Eintragen"); + final JButton btnAutomatisch = new JButton("Automatisch"); + btnAutomatisch.setBounds(8, 770, 200, 24); + btnEintrag.setEnabled(false); + btnBacktrack = new JButton("Backtracking-Schritt"); + btnBacktrack.setEnabled(false); + btnKandidatenListe.setBounds(8, 740, 200, 24); + + AtomicBoolean bEintragungMoeglich = new AtomicBoolean(false); + ActionListener alKandidaten = new ActionListener() { + public void actionPerformed(ActionEvent evt) { + bEintragungMoeglich.set(sp.kandidatenMengenErstellen()); + if (bEintragungMoeglich.get()) + { + btnEintrag.setEnabled(true); + } + else // Fehler -> Zurückgehen + { + btnBacktrack.setEnabled(false); + btnAutomatisch.setEnabled(false); + lblSackgasse.show(); + } + btnKandidatenListe.setEnabled(false); + sudokuPanel1.repaint(); + } + }; + ActionListener alEintrag = new ActionListener() { + public void actionPerformed(ActionEvent evt) { + bEintragungMoeglich.set(sp.eintragen()); + if (bEintragungMoeglich.get()) // es war eine Eintragung möglich + { + btnKandidatenListe.setEnabled(true); + } + else // Man muss raten -> Backtracking + { + btnBacktrack.setEnabled(true); + btnAutomatisch.setEnabled(false); + backtrackingPosition = sp.getPositionVonKleinsterKandidatenmenge(); + if (backtrackingPosition == null) + { + if (sp.istGeloest()) + { + lblGewonnen.show(); + btnBacktrack.setEnabled(false); + btnEintrag.setEnabled(false); + } + return; + } + Kandidatenmenge km = (Kandidatenmenge)sp.getEintrag(backtrackingPosition.x, backtrackingPosition.y); + nextBacktrackIndex = 0; + btnBacktrack.setText("Backtracking-Schritt 1 von " + km.anzahl()); + } + btnEintrag.setEnabled(false); + sudokuPanel1.repaint(); + } + }; + + btnKandidatenListe.addActionListener(alKandidaten); + cp.add(btnKandidatenListe); + cp.add(btnAutomatisch); + + btnEintrag.setBounds(220, 740, 200, 24); + btnEintrag.addActionListener(alEintrag); + cp.add(btnEintrag); + + btnAutomatisch.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + if (btnEintrag.isEnabled()) + { + alEintrag.actionPerformed(null); + } + while(true) + { + alKandidaten.actionPerformed(null); + if (!bEintragungMoeglich.get()) + { + break; + } + alEintrag.actionPerformed(null); + if (!bEintragungMoeglich.get()) + { + break; + } + } + } + }); + + btnBacktrack.setBounds(220+212, 740, 200, 24); + btnBacktrack.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent evt) { + int versuch = ((Kandidatenmenge)sp.getEintrag(backtrackingPosition.x, backtrackingPosition.y)).alsArray()[nextBacktrackIndex]; + SudokuGitter spNeu = sp.klonErzeugen(backtrackingPosition.x, backtrackingPosition.y, versuch); + } + }); + cp.add(btnBacktrack); + + addWindowListener(new WindowAdapter(){ + public void windowClosing(WindowEvent e){ + if (parent != null) + { + parent.setEnabled(true); + parent.nextBacktrackStep(); + } + } + }); + setVisible(true); + } + + private void nextBacktrackStep() + { + if (this.backtrackingPosition != null) + { + Kandidatenmenge km = (Kandidatenmenge)dasSpiel.getEintrag(backtrackingPosition.x, backtrackingPosition.y); + nextBacktrackIndex++; + if (nextBacktrackIndex >= km.anzahl()) + { + btnBacktrack.setEnabled(false); + btnBacktrack.setText("Backtracking-Schritt"); + lblSackgasse.show(); + } + else + { + btnBacktrack.setText("Backtracking-Schritt "+(nextBacktrackIndex+1)+" von " + km.anzahl()); + } + } + + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuGitter.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuGitter.java new file mode 100644 index 0000000..9de53c9 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuGitter.java @@ -0,0 +1,504 @@ +import java.util.ArrayList; +import java.util.function.Predicate; +import java.awt.Point; + +/** + * Repräsentiert ein 9x9-Sudoku-Gitter + * + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class SudokuGitter +{ + /** + * Die einzelnen Felder des Gitters + * Erster Index = x-Koordinate + * Zweiter Index = y-Koordinate + */ + private Eintrag[][] felder; + + /** + * Verweist auf das Fenster, in dem das Gitter dargestellt wird + */ + private SudokuFrame theFrame; + + /** + * Erzeugt ein neues Gitter mit dem Rätsel Nr. 100 + */ + public SudokuGitter() + { + this(100); + } + + /** + * Erzeugt ein neues Gitter mit dem Rätsel Nr. 100 + * @param nummer Die Nummer des Spiels + */ + public SudokuGitter(int nummer) + { + this(SudokuRaetselDB.getRaetsel(nummer)); + } + + /** + * Erzeugt ein neues Gitter mit durch den String beschriebenen Spiel + * @param spiel Eine String-Codierung des Spiels + */ + public SudokuGitter(String spiel) + { + this(spiel, null); + } + + /** + * Erzeugt ein neues Gitter als Kopie eines anderen Gitters + * @param vorlage Die Vorlage für das neue Gitter + */ + private SudokuGitter(SudokuGitter vorlage) + { + this(vorlage.toString(), vorlage.theFrame); + } + + /** + * Erzeugt ein neues Gitter mit durch den String beschriebenen Spiel + * @param spiel Eine String-Codierung des Spiels + * @param parent Das übergeordnete Fenster des neu erzeugten Fensters (kann auch null sein) + */ + private SudokuGitter(String spiel, SudokuFrame parent) + { + felder = new Eintrag[9][9]; + char[] cSpiel = spiel.toCharArray(); + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (cSpiel[9*j+i] != '.') + { + felder[i][j] = new BekannteZahl(Integer.parseInt(""+cSpiel[9*j+i])); + } + } + } + theFrame = new SudokuFrame(this, parent); + } + + /** + * Wandelt das Gitter in seine String-Darstellung um + * @return Eine String-Darstellung des Gitters + */ + public String toString() + { + StringBuilder sb = new StringBuilder(); + for (int y = 0; y < 9; y++) + { + for (int x = 0; x < 9; x++) + { + if (felder[x][y] instanceof BekannteZahl) + { + sb.append(""+((BekannteZahl)felder[x][y]).getZahl()); + } + else + { + sb.append("."); + } + } + } + return sb.toString(); + } + + /** + * Gibt den Eintrag an der gewünschten Koordinate zurück + * @param x Die x-Koordinate des Eintrags (0 bis 8) + * @param y Die y-Koordinate des Eintrags (0 bis 8) + * @return Der Eintrag an der gewünschten Koordinate + */ + public Eintrag getEintrag(int x, int y) + { + return felder[x][y]; + } + + /** + * Gibt alle Einträge der gewünschten Zeile zurück + * @param z Die Nummer der Zeile (0 bis 8) + * @return Ein Array mit allen Einträgen der Zeile + */ + private Eintrag[] getZeile(int z) + { + return getZeile(z, null); + } + + /** + * Gibt alle Einträge der gewünschten Zeile zurück, die einem Prädikat entsprechen + * @param z Die Nummer der Zeile (0 bis 8) + * @param pred Das Prädikat, mit dem die Einträge geprüft werden sollen; null für alle Einträge + * @return Ein Array mit allen Einträgen der Zeile, die dem Prädikat entsprechen + */ + private Eintrag[] getZeile(int z, Predicate pred) + { + ArrayList a = new ArrayList(); + for (int i = 0; i < 9; i++) + { + if (pred == null || pred.test(felder[i][z])) + a.add(felder[i][z]); + } + return a.toArray(new Eintrag[0]); + } + + /** + * Gibt alle Einträge der gewünschten Spalte zurück + * @param s Die Nummer der Spalte (0 bis 8) + * @return Ein Array mit allen Einträgen der Spalte + */ + private Eintrag[] getSpalte(int s) + { + return getSpalte(s, null); + } + + /** + * Gibt alle Einträge der gewünschten Spalte zurück, die einem Prädikat entsprechen + * @param s Die Nummer der Spalte (0 bis 8) + * @param pred Das Prädikat, mit dem die Einträge geprüft werden sollen; null für alle Einträge + * @return Ein Array mit allen Einträgen der Spalte, die dem Prädikat entsprechen + */ + private Eintrag[] getSpalte(int s, Predicate pred) + { + ArrayList a = new ArrayList(); + for (int i = 0; i < 9; i++) + { + if (pred == null || pred.test(felder[s][i])) + a.add(felder[s][i]); + } + return a.toArray(new Eintrag[0]); + } + + /** + * Gibt alle Einträge des Blocks zurück, in dem die Zelle (x,y) liegt + * @param x Die x-Koordinate der Zelle (0 bis 8) + * @param y Die y-Koordinate der Zelle (0 bis 8) + * @return Ein Array mit allen Einträgen des Blocks + */ + private Eintrag[] getBlockVon(int x, int y) + { + return getBlockVon(x, y, null); + } + + /** + * Gibt alle Einträge des Blocks zurück, in dem die Zelle (x,y) liegt, sonfern diese einem Prädikat entsprechen + * @param x Die x-Koordinate der Zelle (0 bis 8) + * @param y Die y-Koordinate der Zelle (0 bis 8) + * @return Ein Array mit allen Einträgen des Blocks, die dem Prädikat entsprechen + */ + private Eintrag[] getBlockVon(int x, int y, Predicate pred) + { + ArrayList a = new ArrayList(); + int xs = (x/3)*3; + int ys = (y/3)*3; + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 3; j++) + { + if (pred == null || pred.test(felder[xs+i][ys+j])) + a.add(felder[xs+i][ys+j]); + } + } + return a.toArray(new Eintrag[0]); + } + + /** + * Sucht die kleinste Kandidatenmenge im Gitter und gibt ihre Koordinaten als Point zurück + * @return Die Koordinaten der kleinsten Kandidatenmenge; null, wenn keine Kandidatenmenge im Gitter steht + */ + public Point getPositionVonKleinsterKandidatenmenge() + { + int min = 10; + Point p = null; + for (int y = 0; y < 9; y++) + { + for (int x = 0; x < 9; x++) + { + if (felder[x][y] instanceof Kandidatenmenge) + { + Kandidatenmenge km = (Kandidatenmenge)felder[x][y]; + if (km.anzahl() == 2) // besser kann es nicht werden + { + return new Point(x,y); + } + if (km.anzahl() < min) + { + min = km.anzahl(); + p = new Point(x,y); + } + } + } + } + return p; + } + + /** + * Trägt eine Zahl ins Gitter ein, wenn es möglich ist. Wenn ja, löscht es alle Kandidatenmengen aus dem Gitter + * @return true, wenn eine Eintragung möglich war; false sonst + */ + public boolean eintragen() + { + boolean ergebnis = nackterEinerEintragen(); + if (!ergebnis) + { + ergebnis = versteckterEinerEintragen(); + } + if (ergebnis) + { + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (felder[i][j] instanceof Kandidatenmenge) + { + felder[i][j] = null; + } + } + } + } + return ergebnis; + } + + /** + * Trägt eine Zahl nach der "Nackter Einer"-Technik ins Gitter ein. + * @return true, wenn eine solche Eintragung möglich war; false sonst + */ + private boolean nackterEinerEintragen() + { + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (felder[i][j] instanceof Kandidatenmenge) + { + Kandidatenmenge kl = (Kandidatenmenge)felder[i][j]; + if (kl.anzahl() == 1) + { + int wert = kl.alsArray()[0]; + felder[i][j] = new BekannteZahl(wert); + System.out.println("Schreibe " + wert + " an Stelle (" + i + "," + j + "), nackter Einer"); + return true; + } + } + } + } + return false; + } + + private BekannteZahl versteckterEinerEintragen(Kandidatenmenge km, Eintrag[] andereZellen) + { + Set ohneAlleAnderen = km; + for (Eintrag e : andereZellen) + { + ohneAlleAnderen = ohneAlleAnderen.differenz((Kandidatenmenge)e); + } + if (ohneAlleAnderen.anzahl() == 1) + { + return new BekannteZahl(ohneAlleAnderen.alsArray()[0]); + } + else if (ohneAlleAnderen.anzahl() > 1) + { + System.out.println("das dürfte nicht sein"); + } + return null; + } + + /** + * Trägt eine Zahl nach der "Versteckter Einer"-Technik ins Gitter ein. + * @return true, wenn eine solche Eintragung möglich war; false sonst + */ + private boolean versteckterEinerEintragen() + { + // Suche Zahl, die nur einmal in Gruppe auftritt + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (felder[i][j] instanceof Kandidatenmenge) + { + Kandidatenmenge km = (Kandidatenmenge)felder[i][j]; + BekannteZahl bz = versteckterEinerEintragen(km, getZeile(j, x -> x instanceof Kandidatenmenge && x != km )); + if (bz != null) + { + felder[i][j] = bz; + System.out.println("Schreibe " + bz.getZahl() + " an Stelle (" + i + "," + j + "), versteckter Einer in Zeile"); + return true; + } + bz = versteckterEinerEintragen(km, getSpalte(i, x -> x instanceof Kandidatenmenge && x != km )); + if (bz != null) + { + felder[i][j] = bz; + System.out.println("Schreibe " + bz.getZahl() + " an Stelle (" + i + "," + j + "), versteckter Einer in Spalte"); + return true; + } + bz = versteckterEinerEintragen(km, getBlockVon(i, j, x -> x instanceof Kandidatenmenge && x != km)); + if (bz != null) + { + felder[i][j] = bz; + System.out.println("Schreibe " + bz.getZahl() + " an Stelle (" + i + "," + j + "), versteckter Einer in Block"); + return true; + } + } + } + } + return false; + } + + /** + * Prüft, ob das Spiel gelöst ist + * @return true, wenn das Spiel gelöst ist; false sonst + */ + public boolean istGeloest() + { + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + if (!(felder[i][j] instanceof BekannteZahl)) + { + return false; + } + } + } + return true; + } + + /** + * Erzeugt einen Klon des aktuellen Gitters und setzt eine Zelle auf einen bestimmten Wert + * @param x Die x-Koordinate des zu setzenden Feldes + * @param y Die y-Koordinate des zu setzenden Feldes + * @param wert Der zu setzende Wert + * @return Die Kopie des Gitters + */ + public SudokuGitter klonErzeugen(int x, int y, int wert) + { + SudokuGitter sp = new SudokuGitter(this); + BekannteZahl raten = new BekannteZahl(wert); + raten.setMarkiert(); + sp.felder[x][y] = raten; + sp.theFrame.setTitle("Sudokus lösen: Versuch (" + x + "," + y + ") <- " + wert); + return sp; + } + + /** + * Trägt in allen Zellen des Gitters, an denen bisher null steht, die Kandidatenmenge ein + * @return true, wenn alle Kandidatenmengen nichtleer sind; false sonst + */ + public boolean kandidatenMengenErstellen() + { + boolean bLeereMenge = false; + for (int i = 0; i < 9; i++) + { + Eintrag[] spalte = getSpalte(i, x -> x instanceof BekannteZahl); + for (int j = 0; j < 9; j++) + { + if (felder[i][j] == null) + { + Kandidatenmenge kl = new Kandidatenmenge(); + Eintrag[] zeile = this.getZeile(j, x -> x instanceof BekannteZahl); + for (Eintrag e : zeile) + { + BekannteZahl bz = (BekannteZahl)e; + kl.entfernen(bz.getZahl()); + } + for (Eintrag e : spalte) + { + BekannteZahl bz = (BekannteZahl)e; + kl.entfernen(bz.getZahl()); + } + Eintrag[] feld = getBlockVon(i, j, x -> x instanceof BekannteZahl); + for (Eintrag e : feld) + { + BekannteZahl bz = (BekannteZahl)e; + kl.entfernen(bz.getZahl()); + } + if (kl.istLeer()) + { + bLeereMenge = true; + } + felder[i][j] = kl; + } + } + } + if (bLeereMenge) + { + return false; + } + boolean bAenderung = true; + while(bAenderung) + { + bAenderung = false; + for (int i = 0; i < 9; i++) + { + Eintrag[] bereich = getZeile(i, x -> x instanceof Kandidatenmenge); + if (nackteZweierEliminieren(bereich)) + { + bAenderung = true; + System.out.println("... in Zeile " + i); + if (getZeile(i, x -> x instanceof Kandidatenmenge && ((Kandidatenmenge)x).anzahl() == 0).length > 0) + { + return false; + } + } + bereich = getSpalte(i, x -> x instanceof Kandidatenmenge); + if (nackteZweierEliminieren(bereich)) + { + bAenderung = true; + System.out.println("... in Spalte " + i); + if (getSpalte(i, x -> x instanceof Kandidatenmenge && ((Kandidatenmenge)x).anzahl() == 0).length > 0) + { + return false; + } + } + int row = (i / 3)*3; + int col = (i % 3)*3; + bereich = getBlockVon(col, row, x -> x instanceof Kandidatenmenge); + if (nackteZweierEliminieren(bereich)) + { + bAenderung = true; + System.out.println("... in Block (" + col + "," + row + ")"); + if (getBlockVon(col, row, x -> x instanceof Kandidatenmenge && ((Kandidatenmenge)x).anzahl() == 0).length > 0) + { + return false; + } + } + } + } + return !bLeereMenge; + } + + private boolean nackteZweierEliminieren(Eintrag[] bereich) + { + for (int i = 0; i < bereich.length; i++) + { + Kandidatenmenge a = (Kandidatenmenge)bereich[i]; + if (a.anzahl() != 2) + { + continue; + } + for (int j = i+1; j < bereich.length; j++) + { + Kandidatenmenge b = (Kandidatenmenge)bereich[j]; + if (b.gleich(a)) + { + int[] zweier = a.alsArray(); + for (Eintrag mm : bereich) + { + Kandidatenmenge m = (Kandidatenmenge)mm; + if (a != m && b != m) + { + int vorher = m.anzahl(); + m.entfernen(zweier[0]); + m.entfernen(zweier[1]); + if (m.anzahl() != vorher) + { + System.out.println("Nackter Zweier " + zweier[0] + "" + zweier[1]); + return true; + } + } + } + } + } + } + return false; + } +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuPanel.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuPanel.java new file mode 100644 index 0000000..1160643 --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuPanel.java @@ -0,0 +1,99 @@ +import javax.swing.*; +import java.awt.*; + +/** + * Ein Panel, in dem das Sudoku-Spiel gezeichnet wird. + * Hier sollte nichts verändert werden. + * @author Rainer Helfrich + * @version Dezember 2020 + */ +public class SudokuPanel extends JPanel +{ + /** + * Das Spiel, das dargestellt werden soll + */ + private SudokuGitter dasSpiel; + + /** + * Erzeugt ein neues Panel + * @param s Das Spiel, das dargestellt werden soll. + */ + public SudokuPanel(SudokuGitter s) + { + dasSpiel = s; + } + + /** + * Zeichnet das Spiel auf ein Graphics-Objekt + * @param gg Das Graphics-Objekt, auf das gezeichnet werden soll + */ + public void paintComponent(Graphics gg) + { + Graphics2D g = (Graphics2D)gg; + g.setColor(Color.WHITE); + g.fillRect(0,0,getWidth(),getHeight()); + g.setColor(Color.BLACK); + g.setStroke(new BasicStroke(5)); + int w = getWidth()-5; + int h = getHeight()-5; + g.drawRect(2, 2, w/3, h); + g.drawRect(2+w/3, 2, w/3, h); + g.drawRect(2+2*w/3, 2, getWidth()-2*w/3-5, h); + g.drawRect(2, 2, w, h/3); + g.drawRect(2, 2+h/3, w, h/3); + g.drawRect(2, 2+2*w/3, w, getHeight()-2*h/3-5); + g.setStroke(new BasicStroke(2)); + for (int i = 1; i < 9; i++) { + g.drawLine(2+i*w/9, 2, 2+i*w/9, h); + g.drawLine(2, 2+i*h/9, w, 2+i*h/9); + } + int cellWidth = w/9; + int cellHeight = h/9; + for (int i = 0; i < 9; i++) + { + int x = 2+i*w/9; + for (int j = 0; j < 9; j++) + { + int y = 2+j*h/9; + Eintrag e = dasSpiel.getEintrag(i, j); + if (e == null) + { + continue; + } + Rectangle r = new Rectangle(x+5, y+5, cellWidth-10, cellHeight-10); + e.zeichneDich(gg, r); + } + } + } + + /** + * Zeichnet einen String in einem Rechteck zentriert auf ein Graphics-Objekt + * @param g Das Graphics-Objekt, auf das gezeichnet werden soll + * @param text Der zu zeichnende Text + * @param rect Der Bereich, in den der Text zentriert werden soll + */ + public static void drawCenteredString(Graphics g, String text, Rectangle rect) { + drawCenteredString(g, text, rect.x, rect.y, rect.width, rect.height); + } + + /** + * Zeichnet einen String in einem Rechteck zentriert auf ein Graphics-Objekt + * @param g Das Graphics-Objekt, auf das gezeichnet werden soll + * @param text Der zu zeichnende Text + * @param x x-Koordinate der linken oberen Ecke des Rechtecks + * @param y y-Koordinate der linken oberen Ecke des Rechtecks + * @param w Breite des Rechtecks + * @param h Höhe des Rechtecks + */ + public static void drawCenteredString(Graphics g, String text, int x, int y, int w, int h) { + // Get the FontMetrics + FontMetrics metrics = g.getFontMetrics(); + // Determine the X coordinate for the text + x += (w - metrics.stringWidth(text)) / 2; + // Determine the Y coordinate for the text (note we add the ascent, as in java 2d 0 is top of the screen) + y += ((h - metrics.getHeight()) / 2) + metrics.getAscent(); + // Draw the String + g.drawString(text, x, y); + } + +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuRaetselDB.java b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuRaetselDB.java new file mode 100644 index 0000000..dd7eacb --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/SudokuRaetselDB.java @@ -0,0 +1,444 @@ + +/** + * Eine "Datenbank" mit 400 Sudoku-Rätseln + * + * @author Rainer Helfrich + * @version Dezember 2020 + * + * Rätsel erzeugt mit https://qqwing.com/generate.html + */ +public class SudokuRaetselDB +{ + /** + * Gibt das gewünschte Rätsel zurück + * @param nummer Die Nummer des Rätsels + * @return Das Rätsel als String codiert. + */ + public static String getRaetsel(int nummer) + { + if (nummer < 0 || nummer >= 400) + { + return "................................................................................."; + } + System.out.print("Rätsel Nr. " + nummer + " ("); + if (nummer < 100) + { + System.out.print("einfach"); + } + else if (nummer < 200) + { + System.out.print("mittel"); + } + else + { + if (nummer >= 300) + System.out.print("sehr "); + System.out.print("schwer"); + } + System.out.println(")"); + return raetsel[nummer]; + } + + private static String[] raetsel = { + "..42...18..2.4....1..68..9.26...9..7...7..28..87...9.3...4.....4..........8.3..2.", + ".5.6.3......2.......3.7.....2..69.574.....8.97..54..26....2.6......8..34...9.62..", + ".642....99...5....1.54.8..624....3.........1..8.3.1452.2.....6.......8.3.....42..", + "...3..15.....1.......7.......36...4..7.2853..8.1..76..7..52...3.2.8..4...3...6...", + "6..21..9...85....6.4.9..82.1..4.6.5.....7.2.94.9..5.7...........8.......5.264....", + "5...6...973.2..4.....5..3......2.6..3........8..4......5.9.8.7..2.....356.7...9.8", + ".9....45.......3...5..3.127..849..7..29.538...7.2...9..8....74...........43..591.", + "1......4.8.7..2.1.2.......9..9..43..3.8...7.4..286...........7173..9.48......69..", + "...693..2..4...........13......8.9......4..37...1.98..4.1...69.37......1...2.6...", + ".8.....4........6...931....8.649..237.........4..3..174...61.9..92....3...7......", + "...6.8.....59.4.3..9.2.....5.7........672...5.4...3..2.......4.862......9....53..", + "..9..6.4....4...2.5......7......7.....5......76...9.....1.5.3..3.462.5..9...741..", + "...2.....9..71....1............8.2.78..9....37.91....5.8..7.43......45.84...5.1.2", + ".93..518..2.....34..51....7.7...3......981.....927......249..........8....1..29..", + "8.....2..2.9.7..38.....1.7......6......3.2.41.8479.3..31....78..........76.......", + "..47.....56...917..1.6.54.8.5..367.4..3..851.....7........4............9......85.", + "6....34.......539........6...6.......35.4982...968..7..435....9.2.....4.......2..", + "...6.1.3..2.9.....85..27.6....8......3..5....5...6.......3.9.7.9.1.....6.7..1..59", + "..........8....1.49.1..7.2.......872....4..1.........3..85...3.7...91..5.5.42...8", + ".........7.....6....5.....8..9.283.717.69.....2.3..1.....8...1.5.6..18.3..8...7.2", + "3..91....4....59..1...2.......486...8...5.2........1...5.2...98.6..4.....1.6.9.4.", + ".37....1...............54...1.2.8..4.9..13.7.7.5.....14..............29835...97..", + ".1.9..8..5..1....286......3...3.8..7..5.26......5........6......87..2.9...9....56", + "...6952.7...4..3.8........5...9.3.5.....7...29...5...65....28.473..64...8........", + "5.......123.9.6.....9..53.44.5..3..7.1.6.9..576..4..133.....1........7....7.....6", + "..........8...9....9...1..26..4..89532..95.6...........14....8.96..2..1.......2.3", + ".78.41.5.4........9.15...48...3..5...42..7...8..95.71.137.....9......3...........", + "4.568.1..........6..831...9........33...5.8.2......95...1.3..25.2....3..8.4.6....", + "...5.7.1..7......2...9.......18..6..98.65.1..5.6.......3...2..7...13..8......8.9.", + "7.26....4.3...4....16......1....24..2.98167....3.9.....2....9.6.91.3.........7.1.", + "9.3....71....65..2..........1..........82..9.......5.6.3....1.7..92....32.7...86.", + ".2...896......9.5718..........29.6...6....24..4.....18........4..6...1..57.....2.", + "...7..4.5.......934....167....2.3.......1....562.9.....3..6791.2..13.........5...", + "149.2....3.8..............196...2.......4.76...2....84....74893.8..6..1...3......", + "2.157....56..8.....8...1...............246....16..7.4...8.2.6....746312...27....4", + "648.....79.73....5.5....18.3......6..65...734..4.......7..8..16........8..9..45..", + ".......4..7..39.....9..7..5..3...4...1.....28..4.....1.589.....2..7.41...3..1.8.9", + "9..........47...........9.31..98.......2.......5..1.74...87.4..3..1.25..257.3..1.", + "8..9...7..64...39.....542.8....6.......3.8.5..7..4......7..246...387....5....3...", + "8..5..7...9.........3.81.2...5.........162......7..6.2........1...92.58.9..6.3.7.", + "4..6.2............5.379.4...2...6.8375...8.6..3.4.....9.7.436.....9.......6.2....", + "....6....8.....9.4.............3......7..438.4..6.8..5..6..14.95..8..13..193..87.", + "....4.3..6.4.9..7..237....956....72...2......1....5.64.5.......9....3....3.....12", + ".............6.......79...2..4.....57.2.85...5....918.2...479.1.57......19.8...64", + "7..48.3.92...69......7...8..9.6..24.......9..5....36...5...........9.4......32.7.", + "..6.....2425...1.6.....3.5..13.9...4......38..4....2.9..8.......64.8....39...26..", + "..3..29..19.46..7.2..7.8..3..8.7...........3292....71........4..1...9...34.......", + "..7.4.....1...3...93.812....9...748...832.1.9.2..........9..........18..3815.4...", + "87..3.4...........1.29..7.8...21...4.19.87............3....5.9.9.73.....481.7....", + "........1.....19.58.........6..8....5...7..23.7.39.8..9...3.6....1625.3...2..9...", + "...6..1.9.....3.6.2....13.5..3.4.29....8.56.........5.4.9.3...2.2.....81....9....", + "3.....1...5..7...26...159.77.46........4..53..29..3.6....2....5....9......1......", + "4...8.6.297..2..5.8.3........4....7...8.7.2.4..7..5..9......5...5.3...4.......827", + "5...9..18...3..4........35.....6.2.3........7....53.9.41.82....3....9.2..795.1.4.", + "............4...89.......6...4.5.81...5.9.6.3..7.61..534.5......6.91.4..8.9.....7", + "...4.7.....45..937.56..9.......9..65..9..8..38..756.2.......7.....3.4.....2....5.", + "....5.89..3..6.7.15.7.....6.2.9.....7..8...........2...62.8...7..5..73629..3...8.", + ".7.....9.2.9.34.85...7.8..24..2.........57...7..8.96.......5.3........7..4..2..5.", + ".89.....3..475...1....38..4..5.....8...38..1.....42....17.2....43.517...5.2..4...", + "......59..68..41..4.1..2...5.2.....3..3..94.21......8.3...158..6......3..8.....5.", + "...6.7....9.....5..7...198.76...45.9...275...............8........1.67...81.52.94", + "..2......6..4....1.31.9....7..2.4....59.37.............7...2..62.3.6.....9.15.3..", + ".....3..1...98.....7..268...283...14.....496..61...7.2....78......6..2.3......6..", + "....8.......2.6.8.7..31.6..4....821..3.....7.21.67384.84.1...6.396..2............", + ".1...5......36..54....419.......8..36.5.9481.......67.....76435.4.18.7...........", + "........4.2..3.51.....2...3......18...29..7.5....8...9.8..1....1.4..789.39...845.", + "..5..693..3.24..5.6.97.......6...3.................4...4.6.5...37...26.....3..8.2", + "............3..1........3.78....25.63...6..2...248573..4..2.8..6...574....1..3..2", + "83.6.1.....2.....1..5.23....1.8......68....1......7..5.5.7........43....27..86.3.", + ".76..53.......27....2....89...21..6........5......7....3..5....15....93.6..89.2..", + "76..9...3......2.....587.1....2.....9.....1.....3...9....73..86.3...69.......85.2", + "..9...8..18.5...73.36....9...3...5...5.....6.61.....823...186.7.75.29............", + ".3.6...2...5.2..7..2..376..4.....1..8.1....67...4.6.58........1.....3.45..7..8.3.", + "......4.5.29..............6..8.6..9.....5..78.9.23.56...4.8....25...7..3.37.2..4.", + "19.........83.1.....58...........4.6.12.46.58.3.....9..6...413....95......3.....5", + ".4.............5....1..3..44.8..67.1.59....3.......8651..6......9675.3.......4..7", + "4..2865..2...37.9.....5...3...7.........2....7...9....82..7...69.6....3.5.3.6948.", + ".7.....6.......3.53..8.4....1.......7....8523..6..2..4.6.3.....5..7......341..7..", + ".3...7..15.42..9.8.2.58.......7.9.2.......195....4...7.5.81..32........9.......7.", + "96.4...13....968..5..8..9.4..4..3..6....6..7....5.4.......51..........57...6.93.8", + "62...8.3..9........1....5..3...9......4.....6...8.2.....953..848..9..31...64...2.", + "74...9...95.3.6.2....4.8..5......39.8......67..2...4..3...9.7.8.........5.....239", + "...91.2..1.63....43...7.5....3..2.9..5..4967.4.7....2.......3...........64....1..", + ".7...4..232..564.11..2...7................6..46.....3...81....5......2..2.64.37..", + "8..5.......3..1...59176....1..23.......9.58.79.76......3.8.2..6..6.7....2...5.9..", + "4...28.7...6..7..587.94...1...21.7......7.9.6..15...4.9...5...4.........5....9...", + "......9....57....8..69.35.73.2.48..6..4....9..8..3...42.9.........5.....8......29", + "......8...5.49...2.8.35.1.4.....9.7...217..........5....1........8..429...9..3..8", + ".2.......7.6.9....9....2.4...3...129.......36......7...417..2.5..74...9.23.....6.", + "..9.........2.14.8.........6.......3.85.63.....1.45.9......93...23..4....6.8..1.4", + "6.......4...18...598...4....5..7....8.495.1.7..6..8..25.1....26..7......24...7...", + "...5....9..1..2....4.8..56.......4......7.81...4.1.....5...69.82....46..81.7....2", + "9.2.7..58...2....1.81..9.23....1.........7.....4...13..49.81....385.....2.7..4..5", + ".4......52...........5...2938...6....5672..8.9..4.....4....38.....9....6..7.6.2..", + ".....3......18.3..4...79..8.73....4..18.27.........5...............4.1...415.893.", + "18..576.465....7....7...5..53...1...4....8.93.....3....741....8......9.186.....7.", + "....9...2..4.......2...6...3.1.64.7..82...1..4....29.3.7.......1.34....6..9831...", + "..5..6.3....1...98..1..976........598.....2..62..7....2.......1.7..3.......6...23", + "....78.9..9.1...4.1.8...6....26.........5.781.......5..4...68.....21.5..........9", + "....7...9....42..7..6..5...5.27...1..6...14...4.9.68.5.51..9...9.8.2.............", + "..594...78...534..6.2....5.7......464.6...329.3...........9....974...6.8..3...2.4", + "2....9.6.5..........1...3.534..5.....1.73..9.7.5.26.........75..9....1.3.......49", + "..8.5.9..75.......4.....23.91..7.8.2...........5482.....1..3...8..52......3891...", + "7.56.......1........4.2.1.3...46..2.6....8.7..1..3.4......72...8...1...2........4", + "...32...7....8......5...213....47......9..1.5.71...89..42.3.......5..7.........21", + "...2..5.....18...........1..1.7.2..95...3...6..7.9.18.8....7...7..92..6.65.....32", + "5........8.......7....79....9.......4.7.28..62..9.73....85...64.2..6.....4578.2.9", + "......8...9.3.....8.....4....37...2....9.2.1...9....7..3.2.59..7..13.....5.48...3", + ".9....2.5....9....1.......4.4.6.2.....71.4.6.8..9..1..2.....597....7..1.5.....4..", + ".1..78.4.85..2.7....65....1.......979.7.412...61........2.....8.....9......75....", + "7..41....2.........3...9....2.......34.76.2..6.7.95..39....3.2..6.12..4......61..", + "........75.....12..7..41..8....6..1.....728.4......75...76.....1.5..3.6..6.4....5", + "4....6...9....4..3..1..79.8.63.7.....9.3.871.......5....7.........59..........85.", + "9...7..4..42.163..3.6.9..2...3.215................47....5........736..9.......17.", + "..6...7.448........975.4..8..3......71.......6.....9.18.1..5.97....3.5...4.7...1.", + "...2.6...9.....2347..........8.35....3..7..59.......4.34........9.6..37..56.....2", + "54.....9..219....68..312....8.6..51.2.6.....9..4.5..3.9...6.....3....8..........5", + "..9.5...21.543.....239.....3.1.....5.......8....81..9...4.....6...6..23..6...8..4", + ".9......4.1...6....68739.2..3..2..........5...2.....1...324..8..7...1.3...26.....", + ".7..6...3.684....2.....8....2..93....3...75....9....8..876.9..........5.2.......4", + ".......9..9........3..15..6.126..58.6..1..........9.3........592...38...58.7...2.", + "2....8.67.3.217....8....3........7..5.....8.....5.4....4...3....2.6.158.7..8....1", + "1..4.......69.23...........2.4..571..79..14.6........24.7.5.19........35.5......4", + "7.....8..3.4..759...2.93.6..43.6.....6...5.3.8...4..........7.55....2.......78...", + ".....6.....92.4.....3...8.4...73..589......42...9..3....6...78.8...2..9.....796.5", + "793.....5....6.......3.1..8.3.1......57.....96.9....73......9..184.....6.76..5.8.", + "....3........2..6....698..1.8......3..6.1.52........1.1..2...844...6...92...49.3.", + "5..7.....86.5..4.3.......8.15.8.4...63........4..1.3..7..1...5........27......1.6", + "1..........8....6296...3.1...9...82.6.1..9.37.3........74.........9.4..88....6.71", + "9..5.1.2...39.....8....6..1..6.1..3..3.275.1.18..9.5.2............8...9......2..8", + ".9....8..7..3...........6.4.5.7...4...3..9...6.82.3....8.....73..6...48..3..4.5..", + "1.7.5.....3.......5...89.3........42.8..7......25.1....94..83..8..4..........21..", + "9......12135.2.8.......8..5.186..3....4.......2693....8....62........5.9.......6.", + "..57...6.9....4.....2.....4.972...1.46......5.5..41........6.73.1..7952.......1..", + ".....89..4........2.9.31......3....2.....4..1.1.58..9.3.1..62...9..4..8....2.9.5.", + "......18...6.....3..16.24.....8....5...536..8....74....1..8..7..38...561..4..3...", + "73...1.......3...45.2..................1...4...48..51...56.2..7.1..7348...85....6", + "..3...1..6..25..4.4..........2...........63......1.....4.62.85.5...812.37.......1", + "6..31.5.............3......5.916.7.316........7......59.18.2.....2....98.8.7...1.", + "...3...5..9...281...4...9.27...59...8....174.........89.2..7........3......428..3", + "1....3..5..2...3.4.3.48..178.1......37..2..58.....64....71.2........4............", + ".3..9.5....5..3.9..29..6.8.57.8......9.....7....5.....71.....6.....6....6...1.827", + "...1.52.8.2.4..16........4.1......2..423......3.....5...1.467....67..8...8.2.1..6", + ".....63..3.89..2.62.......4.7.4........6...35...57...2..3....5....7.8....24.....3", + ".3....5.....2....45194....8......6.2....9.....83.469......3.1......68.93...9.....", + "8...7.....7314......16.........2......291..43..94.86.77...6..1.21........34......", + "....9...2..............6.1.6.2..15....1..9....5.4.3.....46.279..9..3...413..4..5.", + "..5.1..6.92..5.4.1..38..5..582..36....49.............2.......8.3.14.......6..2...", + ".......67.3...1....2.........18.7.3....1.6.8..7..3964...92...13264..3..93....8...", + "4...63.......5.21..65..79......295.....7.1..2......4....71..62....634.........3.5", + "16....37.5.........83...2....2..516.....3...4..1......41.3...2.......6..3562..81.", + "..12..7.6..79......2.7.5.9.....6.54.4.5...8.26..8....1.....8...9.......4.....1.5.", + "..29...1.....15.377...2....42........8.....7.5........9.5..4.818...5.7.4.3..71.9.", + "1.3..4.7.....8...2.6..1..........5....4..3..6356.......82....3..7.......5...621.4", + "38.45..1..17....9...5.8.7...4.89.......716..9.....5....3.16..............51...8.7", + "....42.38.6.38........95..6......5.7649.......5..2.4.......67.3.........8.3..7.9.", + "...9.2.5....38.9..5...1..6.32...............1.7.......93.5....285...1.7...1..7..8", + "......6....5....7....296...52.93..1.......7...3..67.9...3.2.9.......5.81..168...2", + "....9..6......3...6.5......1..2..4...9..6..1..3...5..28......51.1..5.2......34.9.", + "2...9.....861.3..5.3........12..98....9.2....57.8.1.9.3....7....5...863........5.", + "8.49.27...7..8..4...6...28..5.4.......753.9......7863...2..4.............4...3.9.", + "5..1..9....8...1...9......33....1.9....6..8..1..3.56.4....685.......4.2..26.3....", + "2.4.8..6....6......6.235....3..615.4..89....6...8..............48..9.2..5.1...3..", + "..4.....3..35..8.....1....28....1.962.9.5..481....42..3...6.......9...1....2....5", + "67.4..32.....8..14..1.....9.8.3.2.....4.7.....3.81......3.69.4..4.....7......3...", + "4....1.57.3.6.....16..5...9..9....8...576.9.18......7.....95........4...7.38.....", + "........5642.......751......8.6.1..77..2..5.8....8..1.8..35.46......2.5...47.....", + "..79......1....2.7.....8....78..3..2.32..5..8.91...6...6..7.9.......6.1..2.8...5.", + "4.6..8.2...5.....77..9.3.469...............5......79...32.......8.5........4..832", + "274....9.......5.65....9...6......4.42.............18791...4..8...6....1.561.79..", + "4.6.3..9..219.6...3..14..6.....8.......613.4.......38951.2.....8..........48.....", + ".4.21..6.2.....94..7.4.9.587.46.5...8219......5........6...7..........8.9..5.....", + ".542...3....14.....3.6....9.7.3....2.....9..46.97...5.24....9..3...1.........6..5", + "..4......9.2.8.....6.3.78...73.....95..67.2..24.5.9......8......5..32..6329......", + "5.8.67..16..5.19....9.2....19.6..........4...475.....6.5.........1.78..52...1....", + ".1.........7...89.29..............177..28.6.5.3..1..2..6.3.....5.89....61..8.5...", + "..7.6258.....8..195..........32.9....8.5...3..5...6....3.......7...1..6.812......", + "1..6....3..9..52....24..8..2..8.....58..149.........1.4.........53...4.6.9.....2.", + ".2..4.5.....5.2...........7.8...........7621.....517..5.16...9826...........97...", + "..521....9...8.......5.4..22.1.......7.......3.47.1.9.8.7.2.3...9.1......4...9..8", + ".97.3.....8...........4...9....91.....5..2.91...3....82......7.7.35..94.8.47...5.", + ".531....4..6....9..24....6..8..35.1....2.693....48.2....564..2...9.5.............", + "9.1..6.......5...464...97....4...5...3....6.117....32..........4596.3....63...4..", + "..415...7.7....62.....24.8.7..9......9....5.8.5....76....6..8.2..6.......28....9.", + "...12.3.......5....8....7.1..52.....867......3...9..5.9..3..16..7.6....9..6....3.", + "..316..7.9....74...7.....68....75...65..8.....47.1.5.3...4.....1.....7....9......", + ".1.2.....9.3.61..5..2.....3.7..1..........4....9..5......7.6....45.936....1.5..7.", + "8..96...5.....1.3.132...69.6...123..3.1.5...4.....95....42..1..2....8............", + "..........437...1.561......675419.3..........4.9......79...14.6....6...81..85..7.", + "..4.9....28...6.....6.3.....3.8....94...138...2....34.6........513...6....9.42...", + "31................8...63...2..7.5.83.......4.13...46......5.4....3.1..72.7.8...51", + ".641.....19.37.6..3.8.......56...1..7...9.....4......7...96.4.5...5...78.8..3....", + "9....1..4.............5...9.89.....65...28.......3..51..15.42..3...8..9.....631..", + "....9....5..3..61.4.165......2.3.16.7.......5...1.7..9.4.5.37.2......5.....72....", + "1.87.92....5........324.57....9.1.8.3..8.4..72.....1.....5.2.......37......4...5.", + "..6598.........5.9...........8.6....6.19.5..8....21.3..9.1..2..23..5...6..7..2...", + ".2..13.4.3...4571....9..3.2.46.5.........2.....5..1....5...7..94..52....7.9.....3", + "..1.......5...23..8..436......69.1.......8.96.2.1....531.8.4..9985.2.............", + "..2...8.4...9.47....6.5793.83.....6......5..87....2....6.4....7.4.3.....3........", + "5..8..........6..26.84127.........6.274...........81..1......5.8..354.....2...8..", + "6..1.7....8.......1.4.68.........78..9.....2.23..7.61..4....3....9.8....81792....", + "..2.41.9..843........5.9.....3.....7.4..7..298.....4.5...9.28..2..837.......5....", + ".....68..9....32....3.2.79..5..6..7..81.........91...6.....53.1.1........2.6...5.", + "5......371..56....48..73...9..8..6.5..1....7.....1.9.....3.....6..1.8.4......4.5.", + ".3.........2..9......168......3.....1...2...6..6.....7...87..248...1..6..43...19.", + "2...65..7.6.3.1..4....7.1.2.3.......4.5........2...91.926...47.3....9....71......", + "..2...7.9375.1..2.........5..76...8.....916..2..73...........671.....29..6.2..13.", + ".....1...5.64.9..1.34.....5..7......81.7..3..3.9......7...96.58.....7....6.5.87..", + "........9......36...5.8.2.15.2.4.....19.2..56.68..3..........2...4.5...8....1.93.", + "...8...72....728......9..4....1.........4...7..7..816.32....6....1629..3.....1.8.", + "...4...7.3...7...11.83....97......3.......6......6..18..1..8.93..9..4.8.6....9.5.", + "..89.5.....24.1.5....68...4.6..3..4.8..5..1..4.1..9..8.95.............6.31.......", + "5...23.1...3..........64.7..6....2.1.38....672..45.83....2..........5....261.7...", + "..865..47...4.721...........629....5.4.......59.7....278..........2.95....15.....", + "..7..26....2.....8.5.6.8.32.132.4...7..5.....58.31...........56....31...........4", + "..9...8........7..54.7....29.786..1.8.....9...6........7415.68.65...2.74.........", + "8.467.....7.5.8.366.59..........3..84....91.........93.1.7...89.......5...63.....", + ".91....8.....6.3.1.26.91.4.7.431.............8.....1.7...........9.7.8...4...963.", + ".6..7...4.....4..17..69.....8..2....4.79..3...3.4.6..92..1...9...12.7.....8.....3", + ".9..........5.1...1....83.6..1....5...4..3..8.6..2.1...5.4..8...4..125..6..9..2..", + ".81......23....4.....4......4....1......3..9.1.8..9..2..9....363....721..6..1.7..", + "89...71..............95.84...4...519........6..8...4..4.5......98.1.67..67...439.", + ".....15..1.872..3....6...7...2.1.....4......5.3...81.4.87......4...7.....2..5.6..", + "3.....61..8..6...71.6379....3.7.8........48..........224..97.8......3....9..8.43.", + ".5..3....1.7...83.6.........1.....4.463............5.7....57..2..4.2..6..7..46..3", + "......68......23..867..32....9.............18.3....765..3..8...1.8....927..5.9...", + ".3.1.98.4..5.436...6......19..7..4.........67....38...3....1....5.3.6.9.....5....", + ".1..692.7.5.........8..76.3.8.712.......8......5..6...2.....16..9..2...8.3.......", + "782.5....6.........5.1..3......42..75..3.761.8....5.4........7..........2.1...45.", + "68.59....7.......89....2.54.25...........15...6..4...1...8...62....2.74...7....1.", + "4.7....8...2...3..85.43...957.29.....2..4...7...5..2...8.....7.6..9.......4...85.", + "..2.19.....56......6.387..26.......3..7...526.......1...325..9.7..9.8.......6....", + "......15...9.253.6.....79..........5..7..4...2...5......3.....75..9..42..9.41..6.", + "..61......8...7.3...4.3..758....6..........1...342...8.....8....17.63...43...5...", + "............53...9..9..1.5..6..9521..7..265..8.............819....6...8......7.36", + "...2...4......38....6.5.3.98.5.4793..43.......9.....27.32.....84.....59..7.......", + ".7.4.3.......62...6..71.....61.4.5....2.5.......6.14...1.52...3.3....6..74.9..2.1", + ".4....6.3.15....4.39........56.48.39....5..1...3....8......3.955.4...86..79......", + "6......7.5....81.....7.64.......36.1..18.473....6.28.5.........254.......83..7...", + "8.172......6.9.....2..8...7...5..7.....918.....8.4.61....1...29..7....51.9...4...", + ".687..4.......9.3.925....872.4.8..56.9..63...6...........4.....4......6.58......2", + ".5..1..342...6.58.9.....1..3..259..8...1.........839..5....23..........1...53.6..", + "1.69........6.1..7.....4...3..5.74..4....9...879.6..1.98.....5...43........845.6.", + ".3......2..5..4..8.746.35........7.6.6.4...232...9.45.....5.....9..........2..8..", + "....7...3.7..9..2..9....6..8.4.....9....62..1..13....7......7.29..42.186.1...8...", + "...........7...2....8...4.62.........76.49.....432.9.8...2...6.64..1.8.9..38...42", + ".3..216.....46......9.73....1...2.........4...94...72..52..4....6....3.7..1.....4", + "641..............78.2..4.6..579..........2...4....1...72..1.9.61...9.......4.8.15", + ".1...3...459.2...183..5...2..5....4..9....38.1..9......4...56.3...26...........54", + "1..5..9.......8.14........56.4.........1......8..457...68.........63..9.95...137.", + "1.37....4...4.9..1.....5...4.......2...9....7..7..3........7.5..1.3.6..992.15..73", + "8.3...7.97.........9.....1897...6..2.3............1.572.879.5..........1.....3.8.", + "96.32415.....9....3....1.26.......8..3...56.4.4..8..95.....8.398..53...1.......6.", + ".2..........4..7........8....78.4..1.1.92..34.5.3......392..17.8.........7...84.2", + ".5.23.......6..8....8...5.....1......39.6.....4....9...8....4.33.....62.2..45.19.", + "..71..5....98.6..4.51..498...5.4.......5..7...4...1..3398.7...................4..", + ".7.6...38.34.2..5.1...87.2.4.7...6....3..2.8...6.4...7....368......782...........", + "73...5.2..1...84.............3......6.....2..1.4..2.5.87.....3......1.45..67...8.", + ".2..7..5137.8.12.4.5.42....8..5...72...2.........3..4.........5.1.....3.....836.7", + ".....52172....9.5........4.59........42.........8.2......9..174..54.8.....76....8", + "38...2...1.6.5..7.....3.8.92..1...5..1.8...62.5...6....9..2.7.............73.....", + ".......5....182..4....46..2...91....32...4.8.64.............2....83...69....91..8", + ".5.......3..765....8.2..4.15..........36........1...87...3....2..6.7.14....42.76.", + "1..5.27.......76.94....31...4..9.....154.....2....5...69.......7...56....217..4..", + "...5.372....84.3...31........472..8...54.........89...92.....5.....9714.......23.", + "...6...7........1..34........85.4...1..7.3...97..614....13..86..5.....9..6..8.7..", + "..34..8...8...6...2..7..3...4.9..6...72.4....631.....4.....8726.2.....41.........", + "2..3.514.61..2.....3.78.........48.3.2......5...25.47.5...4....7......12......68.", + "2.4......9.1..827.7..5..8.......7...........56...9....1.7..9.....8..4.9..6.2..1..", + "..4...5.....48..1.1...2.7.3.48..5...2...1.35.........2............6.8...3..15.46.", + "......3.4..9....8..4....51.72.......3......9..817.......79.84..29..34.57..52...3.", + "7......8..3.....1..65....3.4.3..5.9.19....5...7............6...8..7.49....7.3.14.", + "2........87..2.9...3.9........2..4..3...1..86.92..67.3..4......9274.8.6..8.......", + ".6.........9.758....1.......2.6.1.459..4..2.....85....6..5.8.....5..918.8......7.", + "..31....278......41.9.......1.....73.46....8......2.6.2.4..6........96...3...4..7", + "..56.....8....1...7...8.......9.85..12...5..7..7...8..2..5.619.4...........2..65.", + ".9.......7.8.3....36.9.....6..72...9...1..58....5....32...5...1.7..6..3.5...7...6", + "23...48757.5.....2.........4..2..5..9.34.8..66......8........54.92...6..86.....9.", + ".1.........9...2.8...5.471...43....9.8....3252..............15..432.5.8..7...1...", + ".3.....9....7.....2..8....7.6.9............35..2.65......23754.....5.3..8..6...7.", + "..51....94...5.1..2.36..4......6.....48...9........821..1.3..9..82.....46...1.2..", + ".1..52.9...536.....931...7....21.9...8.......7..6......59...6.......3...........2", + "....8..9..74....3.9.3.......1...3........9.....987.24.4.8....1..2.51......59..723", + "..83.4.1...2....7......18.....168....86.....3......2..69..1.4.....4.3......9...82", + "...3.6...6.7..9.....97......7..8...2..36....99.4..78.....5...2..5.....372.8......", + "..8....7.36......81..3.6..........34.3.1.97...85..7.....645........18.4.7........", + ".4........3...1.5.8.2.9.1..2...15.6.59.3..81.41.2....3.....4..9...953............", + "4...583..6........89.43....1.89..6.3.....5....4..637.55.7.89.....9.......6.7.....", + "5......2.....9..8....3........9.6.7...758......9.3.5181.5.7..9..76......8....2..1", + "9.....2.........3......9..4..8143...4..2....52....8...5..43.....2..5..1.17.....8.", + "6......21.41..25.3....9.7.............5..741.......63...2.3..469........3.74.6.52", + "..8....56...25..7...3.69.1.1...9.........376..37..........1.....94.2.....5.6...8.", + "...8.1.24.7.9346............2...6....3...27.....14..6...8....3...........92.6..48", + ".6...4.....4..368......9.3...8.1.....9...2...43....81..23..6.9.54.......6..29....", + "..89...5.7.1..2.......7....379..4....4.3.......2.59....1.....4.2.7..83.9.3.2.7...", + ".5.6..23...98.....21..9....4.52...6....9......21.8....8.6..4..........45........1", + ".....9....5..6.4.....7.......8.4..76...93...1.9...154......4..5..159.6.4..5.7.18.", + ".........3.9.....4...796....63......18...49..95..8...14.71...3.5.....4.8...3.9...", + "............38...17...168.99.........5.19..7.84..3......68..7......5.6..3....95..", + "....5.......8..71.5..23.........1..9.25...8....7........392...7..1....5..8....926", + ".....2..8.3...76..8..15..2.74....8....1...23.2...75.6.1..........7.3..5..6.......", + "6......9.....3.58.75.......3.89.4..6.7...3......17...4.9....1..5..6..7.88.6......", + ".......81.........14....2..9...21...8..7...5347..3.......5.4.3..2...9...3.5.7..1.", + "3.4.9.....6.5...8..98..7...5....167.....345...3......8..7.8.........64....5....6.", + ".2............68...1..39.5..3..5.6.........315.......9....63.8.4..5....6..94..2..", + "..6......53..........954.......657...98...6....781...4.......573...7........83.9.", + "3....8.......9.....71.24..58.7.52.9.2..8.........47.2351..........9.3....8..1..4.", + ".7.......419.....76....84......9......13.482.3.26..9..836.41...1..2.6............", + "......6...4............9852..5.3...8..4.96..13.2.5..4...6..42.9.3.....8.8.9......", + ".......6..6...2...2....5.......6....8..4.7...6.4.2.59.5.......3.8..9.4..7..84..2.", + ".........7.....9....92....4.4.13.....16..87.......7.2....9.1..86...7.2.39.43.....", + ".537.6..........59..624......9.6.84...2.....7...8.7.9......9..3.....846....65...8", + ".275........16..4.4....2..9......9.7..59...12........46..2.....5..4.9.6....7..8.5", + ".3..2..8......4...8..61..7.69..8....7.8...2...1.....38..1...9..9.6.3..4.4...72...", + ".472.....8.5.69...2..5.....3..7...4.......25...6...9...9..4.7...3.8.5..4..8.....2", + "34...5.911984...766.5...4.8...6....59...58.....31.4.......3.......5.6...4.19.....", + "...97.....3..1....718..4.....4.5......6..8....8.1...356..3..97..93..........8.4..", + "..5..7.......842.7.2....4...9....6.....42....1.7..9.2.5.4.6..1...1........2.98...", + ".....6.497.....61..5.......3..9...652.....7...71......5.....1.44327.........95.3.", + ".2...4.....8.7.63.9..2....4.....9.5.......2.6...68..4...2...9.3.36.....7.....5...", + "..........9.1....8.....65.....9.8..2.71...9.....2..6..1..7...5...8..4..676..592..", + "..2.....7....4..81.........3.....8696....74...243..7...194...32...72.9.4.....6...", + "3..89.627..87....3.............3..8.6...7.1..2.398...5.......6.9..62......1...9..", + "...1..9.88..2.6..4.......6..5.......9.....72...4.2...5..5...17..92......1...54...", + "........81..6.7.3....341.2.93.....167.193..4.8....2..3.....6.....849....4...18...", + "...5.87...53....1......7..66.1..5..2.329.1.....8.2..5..8......3...6......2....67.", + "8.7.6..9...2.3...6....17.8.316..87.2......9.8...2...1...5......7.......3.....6..7", + "1.7.5..29..4......5..6.2.......7...4...1...9........57.1.54..7.4.9...8...5..2..6.", + "...6...8....1.8.7.....32.....8.7315.1.4.2..........2..75.....4.6.2....1....715..6", + "3.1...25...45..1..92...63....8.4....2.......1.9....6......84.2.....15.....932.4..", + "..573...1....4.6..........96...7.4.5.....9136..........86..4...5..1.....94.3.5..8", + "9...6........15...715.......9.1485..6...9..........8..4.6....75.2..561.9.....4..8", + ".......2.......3...2....78.87.9.4..1..1..2..8.3..5.97....4795...1...84..7.......3", + "....6.43.....5.......1.3...4.1.7..2..37........284..7..2...68.416..8.5.3...5....2", + "....23.7..39...5..2..49.6..46..7.9...2....3.7..8.......96..24..7........5...69...", + "....4852......2..4..7.3....56.....4.7..95......9.....7..63.....92...67..458.7....", + "..6..2..5......4....4..5.96.8.7...63.3..2.95...7.6..2................2.9...3.6..8", + "....6...787.4.3..9.43...5.....3.58.4......73.....4...27..8..6..........5..267...3", + "5...2...86........972..64..4...1.8..76.5.9.4.1.9..8..5......1.6...1...5....4..7..", + "45.3...6.1....9..3..7.........73..4....5846.....9.6..15..61.9...7........83......", + "..9.87.516..91.........2...3.1....9.9......758.2..51......23.....3.7.2.8........9", + "5...3.49.8..4.56...3...9..1.....3.............5...1.32..39...6.48.6....5......8..", + "4...25.1.7...49..2.............61.4.9...74.6...79...........9....2..73.4...23.1..", + "...6.2.....4.5.7.22..7..8.97.2....4.3.....6...95.......69....844...9.3...8..6....", + "..69.7.4..2.3.1...8..62.9........8...4......3.7...9..24...78.2..8....7.63........", + "71..3..68.....6..2..3....4982.4...1....1...83...27.....41..2.....7.....438.......", + "...4...6...23....4.9..2.1.32.7.9.....69......18...32..72........16...9....4.6...8", + "1...4..255....9..88..31.....4...3.......8..92.7..54...4....1.....9...8.1.......57", + ".3.......5...1....91758.4...2..34...4......92..52..14....97.8..8.......5.9.3.....", + ".36...21.528....63....3.........8.9....976.....3.2...76..7....2....19.5....8...3.", + "72...5.....1...96...3.....86.5.18.9..12.....7.......5..6.....3..971....6.....2.8.", + "..9....8....73.........47....3.......8..1.....4..9317.....423...6.87.4.9.....6.1.", + ".8.6.....1...4....763...1............1...75.4576.9......7..4.9.....38....4.7...83", + ".6...2...5......24..2.58.....7.2....4593..7.....54.3......64.7....93.....36.....8", + "....4.5....8.3.....53.9.4.8...76.3...17....9...58........6.397...........7..85134", + "......8...4..2.6.9...6...3...7..31848.......3......7...2...6.....4....9.9.61.83..", + "...86.217.3.9.........5.8....5..197..8..2.....2.3.56..5.....7........19...3..9.5.", + ".1.957...5.9864..............6.2......84952.....7..4.....5....4.41.89...7....269.", + "..........1.3..7...3..46....58....6...9..54.11.3..7.8....4...79.967...1.4...8.6..", + ".....69......7....3.72...5......4....3.8....6...9.2.357....9....49.2.78.85.4.....", + "64.9...7...8......93..24.8..1..7..4..9......6....4.........2..4.2..1..3...638....", + "..47.3.5...........2.6...83........6.5.13...4...82....3...5.1..28.3..4.7.71.....2", + ".897....651..68.3...2...8....3.1..62.2...57.....37..8....28........36...6..5.1...", + "5....2..........2..6...7..1......25...7.3...4.5.2843.....56.83...1..3..7....4.1..", + "16.......2.8.6.......8...4...4.3.85..3..5...2...41...3.5.1.....672.........5...8.", + ".4...9.7.......4233.7......5..8.....9..5.6.872...4.3...95...8.26.........8.4...96", + "8....2.16..6...3...4.....8..3.......9.2.....8..5..9..32.3.8.1.....5...6.51....9..", + "79..4.1..8.3.7..466.453.9......5......6...8......9.753......58......4......78.69.", + ".....6.4..4.72........35..2....8.29.....72..85..6...3...9...87.6...57..4...3..9.6", + ".1....6.4.....1...3.84.......1..2.594.3..5..25...6....6..8.9......253.4.....14.9.", + "....2.75....8.1.6.5..6.........781.......6.2..2.....3...7.....43.6...87......4..5", + "71........29......5.......3.....178......34...4...72..9......7.48.2.......3.19..2", + "8....193...523....9.2.....756...8...........1.9.....6.1..9.2.8......65....7..5...", + "7.65.1....8...7...2.5........24..19.4.....8.6.9.67.5.....8.........56..21...92...", + "...3.......5....87.3.8.7..2..64...15.5..312.62...7...4.....8.5.4.8.6..2.....1....", + "9..7.5.....6.9....18....9.....9.....7...41..84536......3..84..7.......1...4...8..", + "7.12....5.89......25.9...4.4...2.1...7.8.9......46..725..6...2.......9.7.2....5.4", + "..58..7.973.......9.....12.4.3.......78....4..1...........3.8...5.28.97..9..14..5", + "....4368....1..2.4....79..3.9.3.4...............6..921...7.....97...1.3..21.6....", + "1.54..93.2.7...5...94........2.53.......6.157...9............7...9.......6..2..41", + "7.6.5..8..9...6...5...2.....7.1.....85.....2.4....9....4.5..1...1...7.95...4..8..", + "...4.1.....46..19....95.....2..4...6416....3.9.3......3..57..6..51.....77...1..4.", + "196.7........2.9.......47.56.58...2......16.88...47..1..4......7.....8...2.......", + ".3..7.............7...32.8...3.98.655.6....2.8..1....3...9...5...7...2...9...6738", + "2....7..9.3.49..624...3.1....5.....1.2...5.7............36...5..6.......51.9..3..", + "..8...3.1.3.....5.1.6.2...97.5.1..2.3..2.....2..8..57...2...7.....9.8..........18", + "..9.672.....4....1....92....6.2..91...89.1.43........82.....8..4..62.....31......", + ".2..9.81.96...1..2...5....9........5.9.8........2.3....7.....5335..7.19...63...7.", + "5..4.........6..9.286.1.........971..27.5...88.1...4........6..9.....8...15..7...", + "2.9.............9..165....71.....7..4..9.2.15.321..6..94...7.......3....67...5..2", + ".836....449...8.......3................4....81529......6..23....3..6921..15....3.", + "........59...3.2..1.....6.3..9......2....8.464....29....49.....8..1....236.524...", + ".9...6......48.......132.6..2891.5..36....9.1....2.3........6.3.....4.9.6..3..418", + "..12....5.94................3.5...8.948...........2.9..1...3..6.651...4....8.9.2.", + "..5..9...9...5...7.4......6......5..8.2....9.5...42..1.61...8....89...754...6....", + "41........7.1........25.....6..4.2.15....2.36...5...47..6......129.36.7.7.......4", + "3.....59..1.9..6.2..23...71.975..2.....4......2...6...1.........6.7.5..4.7..32...", + ".........2..16.....68..7.....7....6..8.623..15...8..9...3.......9.51...81.5.9....", + "7.82..6..9.6.4.....1465........6.5....1.....2......19...2.94.5.1.582.7.9.4..7....", + ".65127..8..1....52....3.67..........3.4.5.8....7483....5.........83..4.....86...7" + }; +} diff --git a/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/package.bluej b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/package.bluej new file mode 100644 index 0000000..3a39fcf --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/02_sudoku_loes/package.bluej @@ -0,0 +1,127 @@ +#BlueJ package file +dependency1.from=Kandidatenmenge +dependency1.to=SudokuPanel +dependency1.type=UsesDependency +dependency10.from=SudokuGitter +dependency10.to=BekannteZahl +dependency10.type=UsesDependency +dependency11.from=SudokuGitter +dependency11.to=Kandidatenmenge +dependency11.type=UsesDependency +dependency12.from=SudokuGitter +dependency12.to=Set +dependency12.type=UsesDependency +dependency13.from=SudokuGitter +dependency13.to=SudokuRaetselDB +dependency13.type=UsesDependency +dependency2.from=SudokuFrame +dependency2.to=SudokuGitter +dependency2.type=UsesDependency +dependency3.from=SudokuFrame +dependency3.to=SudokuPanel +dependency3.type=UsesDependency +dependency4.from=SudokuFrame +dependency4.to=Kandidatenmenge +dependency4.type=UsesDependency +dependency5.from=SudokuPanel +dependency5.to=SudokuGitter +dependency5.type=UsesDependency +dependency6.from=SudokuPanel +dependency6.to=Eintrag +dependency6.type=UsesDependency +dependency7.from=BekannteZahl +dependency7.to=SudokuPanel +dependency7.type=UsesDependency +dependency8.from=SudokuGitter +dependency8.to=SudokuFrame +dependency8.type=UsesDependency +dependency9.from=SudokuGitter +dependency9.to=Eintrag +dependency9.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=892 +editor.fx.0.x=959 +editor.fx.0.y=44 +objectbench.height=142 +objectbench.width=814 +package.divider.horizontal=0.6 +package.divider.vertical=0.790436005625879 +package.editor.height=542 +package.editor.width=703 +package.editor.x=977 +package.editor.y=47 +package.frame.height=811 +package.frame.width=854 +package.numDependencies=13 +package.numTargets=9 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Eintrag +target1.showInterface=false +target1.type=InterfaceTarget +target1.width=80 +target1.x=270 +target1.y=320 +target2.height=50 +target2.name=Kandidatenmenge +target2.showInterface=false +target2.type=ClassTarget +target2.width=140 +target2.x=160 +target2.y=440 +target3.height=50 +target3.name=SudokuGitter +target3.showInterface=false +target3.type=ClassTarget +target3.width=110 +target3.x=480 +target3.y=260 +target4.height=50 +target4.name=Set +target4.showInterface=false +target4.type=AbstractTarget +target4.width=80 +target4.x=20 +target4.y=310 +target5.height=50 +target5.name=SudokuFrame +target5.showInterface=false +target5.type=ClassTarget +target5.width=110 +target5.x=330 +target5.y=50 +target6.height=50 +target6.name=SudokuRaetselDB +target6.showInterface=false +target6.type=ClassTarget +target6.width=130 +target6.x=560 +target6.y=150 +target7.height=50 +target7.name=SudokuPanel +target7.showInterface=false +target7.type=ClassTarget +target7.width=110 +target7.x=40 +target7.y=120 +target8.height=50 +target8.name=BekannteZahl +target8.showInterface=false +target8.type=ClassTarget +target8.width=110 +target8.x=370 +target8.y=440 +target9.height=50 +target9.name=BitSet +target9.showInterface=false +target9.type=ClassTarget +target9.width=80 +target9.x=20 +target9.y=390 diff --git a/Quellcodes/Alg_DS_Sudoku/readme.adoc b/Quellcodes/Alg_DS_Sudoku/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Sudoku/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Terme/.gitignore b/Quellcodes/Alg_DS_Terme/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/AlsStringTest.java b/Quellcodes/Alg_DS_Terme/01_terme_roh/AlsStringTest.java new file mode 100644 index 0000000..9b5c3a5 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/AlsStringTest.java @@ -0,0 +1,77 @@ +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Testet, ob die String-Umwandlung der Binärbäume korrekt funktioniert. + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class AlsStringTest +{ + @Test + public void test1() + { + testAusfuehren("2*3 + 4*5", "2*3+4*5"); + } + + @Test + public void test2() + { + testAusfuehren("(12/6) /2", "12/6/2"); + } + + @Test + public void test3() + { + testAusfuehren(" 12/(6/2)", "12/(6/2)"); + } + + @Test + public void test4() + { + testAusfuehren("(2+3)*(4 +5)", "(2+3)*(4+5)"); + } + + @Test + public void test5() + { + testAusfuehren("3/2+9/(3+1) ", "3/2+9/(3+1)"); + } + + @Test + public void test6() + { + testAusfuehren("100/5/(9-8)", "100/5/(9-8)"); + } + + @Test + public void test7() + { + testAusfuehren("1*2-3*4+(5*6)-7*8", "1*2-3*4+5*6-7*8"); + } + + @Test + public void test8() + { + testAusfuehren("(1*2+3*4)*((5*6)-7*(89/10))", "(1*2+3*4)*(5*6-7*89/10)"); + } + + private void testAusfuehren(String term, String erwartet) + { + try + { + Binaerbaum b = TermParser.parse(term); + TermAuswerter t = new TermAuswerter(); + String ergebnis = t.alsString(b); + assertEquals(erwartet, ergebnis.replaceAll("\\s", "")); + } + catch(Exception x) + { + assertTrue(x.getMessage(), false); + } + } + +} diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/AuswertungsTest.java b/Quellcodes/Alg_DS_Terme/01_terme_roh/AuswertungsTest.java new file mode 100644 index 0000000..831ac84 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/AuswertungsTest.java @@ -0,0 +1,77 @@ +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Testet, ob die Auswertung der Binärbäume korrekt funktioniert. + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class AuswertungsTest +{ + @Test + public void test1() + { + testAusfuehren("2*3+4*5", 26); + } + + @Test + public void test2() + { + testAusfuehren("(12/6)/2", 1); + } + + @Test + public void test3() + { + testAusfuehren("12/(6/2)", 4); + } + + @Test + public void test4() + { + testAusfuehren("(2+3)*(4+5)", 45); + } + + @Test + public void test5() + { + testAusfuehren("3/2+9/(3+1)", 3); + } + + @Test + public void test6() + { + testAusfuehren("100/5/(9-8)", 20); + } + + @Test + public void test7() + { + testAusfuehren("1*2-3*4+(5*6)-7*8", -36); + } + + @Test + public void test8() + { + testAusfuehren("(1*2+3*4)*((5*6)-7*(89/10))", -364); + } + + private void testAusfuehren(String term, int erwartet) + { + try + { + Binaerbaum b = TermParser.parse(term); + TermAuswerter t = new TermAuswerter(); + int ergebnis = t.auswerten(b); + assertEquals(erwartet, ergebnis); + } + catch(Exception x) + { + assertTrue(x.getMessage(), false); + } + } + +} diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/Binaerbaum.java b/Quellcodes/Alg_DS_Terme/01_terme_roh/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/README.TXT b/Quellcodes/Alg_DS_Terme/01_terme_roh/README.TXT new file mode 100644 index 0000000..f8b599a --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Terme +PROJEKTZWECK: Implementieren Sie das Auswerten von Rechentermen sowie das Umwandeln in eine String-Darstellung +VERSION oder DATUM: November 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ TermFrame +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/Symbol.java b/Quellcodes/Alg_DS_Terme/01_terme_roh/Symbol.java new file mode 100644 index 0000000..ed5c157 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/Symbol.java @@ -0,0 +1,110 @@ + +/** + * Stellt ein Symbol eines Rechenterms dar. + * Frei nach der Abituraufgabe B3 von 2018 + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Symbol +{ + /** + * Der Operator bzw. der Wert des Symbols + */ + private String wert; + + /** + * Erzeugt ein neues Symbol. + * @param s Der Wert des Symbols + */ + public Symbol(String s) + { + wert = s; + } + + /** + * Gibt zurück, ob es sich bei dem Symbol um einen Operator handelt. + * @return true, wenn es ein Operator ist; false sonst + */ + public boolean istOperator() + { + return "+-*/".contains(wert); + } + + /** + * Gibt den Integer-Wert des Symbols zurück + * @return Den Integer-Wert des Symbols, wenn es sich um eine Zahl handelt; 0 sonst + */ + public int getInt() + { + if (!istOperator()) + { + return Integer.parseInt(wert); + } + return 0; + } + + /** + * Gibt zurück, ob es sich um einen Plus-Operator handelt + * @return true, wenn das Symbol "+" ist; false sonst + */ + public boolean istPlus() + { + return wert.equals("+"); + } + + /** + * Gibt zurück, ob es sich um einen Mal-Operator handelt + * @return true, wenn das Symbol "*" ist; false sonst + */ + public boolean istMal() + { + return wert.equals("*"); + } + + /** + * Gibt zurück, ob es sich um einen Minus-Operator handelt + * @return true, wenn das Symbol "-" ist; false sonst + */ + public boolean istMinus() + { + return wert.equals("-"); + } + + /** + * Gibt zurück, ob es sich um einen Geteilt-Operator handelt + * @return true, wenn das Symbol "/" ist; false sonst + */ + public boolean istGeteilt() + { + return wert.equals("/"); + } + + /** + * Gibt zurück, ob es sich um eine Punktrechnung handelt + * @return true, wenn das Symbol "*" oder "/" ist; false sonst + */ + public boolean istPunktRechnung() + { + return istMal() || istGeteilt(); + } + + /** + * Gibt zurück, ob es sich um eine Strichrechnung handelt + * @return true, wenn das Symbol "+" oder "-" ist; false sonst + */ + public boolean istStrichRechnung() + { + return istPlus() || istMinus(); + } + + /** + * Wandelt das Symbol in seine String-Darstellung um + * @return Die String-Darstellung des Symbols + */ + @Override + public String toString() + { + return wert; + } +} diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/TermAuswerter.java b/Quellcodes/Alg_DS_Terme/01_terme_roh/TermAuswerter.java new file mode 100644 index 0000000..e6de6b3 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/TermAuswerter.java @@ -0,0 +1,31 @@ + +/** + * Wertet einen Term aus, der als Rechenbaum gegeben ist + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class TermAuswerter +{ + /** + * Wertet den Term, der durch den Binärbaum b gegeben ist, arithmetisch aus + * @param b Der auszuwertende Baum + * @return Das Zahlergebnis des Terms + */ + public int auswerten(Binaerbaum b) + { + //# TODO: Implementieren Sie die Auswertung des Rechenbaums n + return 0; + } + + /** + * Wandelt den Term, der durch den Binärbaum b gegeben ist, in eine lineare Termdarstellung um + * @param b Der umzuwandelnde Term + * @return Der Term als lineare Zeichenkette + */ + public String alsString(Binaerbaum b) + { + //# TODO: Implementieren Sie die Umwandlung des Rechenbaums in eine lineare Textdarstellung + return ""; + } +} diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/TermFrame.java b/Quellcodes/Alg_DS_Terme/01_terme_roh/TermFrame.java new file mode 100644 index 0000000..dc06095 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/TermFrame.java @@ -0,0 +1,142 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +/** + * + * GUI zum Verarbeiten von Termen + * Hier sollte nichts verändert werden. + * + * @version 1.0 vom 05.11.2020 + * @author Rainer Helfrich + */ + +public class TermFrame extends JFrame +{ + private JTextField jTextTerm = new JTextField(); + private JTextArea jTextTree = new JTextArea(""); + private JTextField jTextErgebnis = new JTextField(); + + public TermFrame() { + super(); + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 408; + int frameHeight = 580; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Termauswertung"); + setResizable(true); + Container cp = getContentPane(); + cp.setLayout(null); + + jTextTerm.setBounds(96, 8, 289, 25); + jTextTerm.setFont(new Font("Courier New", Font.PLAIN, 12)); + cp.add(jTextTerm); + JScrollPane jTextArea1ScrollPane = new JScrollPane(jTextTree); + jTextArea1ScrollPane.setBounds(8, 40, 377, 465); + jTextTree.setEditable(false); + jTextTree.setFont(new Font("Courier New", Font.PLAIN, 12)); + cp.add(jTextArea1ScrollPane); + jTextErgebnis.setBounds(96, 512, 289, 25); + jTextErgebnis.setEditable(false); + jTextErgebnis.setFont(new Font("Courier New", Font.PLAIN, 12)); + cp.add(jTextErgebnis); + JLabel lErgebnis = new JLabel(); + lErgebnis.setBounds(8, 512, 78, 20); + lErgebnis.setText("Ergebnis:"); + cp.add(lErgebnis); + JLabel lTerm = new JLabel(); + lTerm.setBounds(8, 8, 78, 20); + lTerm.setText("Term:"); + cp.add(lTerm); + + jTextTerm.getDocument().addDocumentListener(new DocumentListener() { + public void changedUpdate(DocumentEvent e) { + parseTerm(); + } + + public void removeUpdate(DocumentEvent e) { + parseTerm(); + } + + public void insertUpdate(DocumentEvent e) { + parseTerm(); + } + + }); + addComponentListener(new ComponentAdapter() { + public void componentResized(ComponentEvent e) { + jTextArea1ScrollPane.setSize(getWidth()-31, getHeight()-115); + jTextErgebnis.setSize(getWidth()-119, 25); + jTextTerm.setSize(getWidth()-119, 25); + jTextErgebnis.setLocation(96, getHeight()-68); + lErgebnis.setLocation(8, getHeight()-68); + } + }); + setMinimumSize(new Dimension(300, 300)); + setVisible(true); + } + + private void parseTerm() + { + jTextTree.setText(""); + jTextErgebnis.setText(""); + try + { + Binaerbaum rechenbaum = TermParser.parse(jTextTerm.getText()); + String ausgabe = baumAnzeigen(rechenbaum); + if (rechenbaum != null) + { + TermAuswerter ta = new TermAuswerter(); + int ergebnis = ta.auswerten(rechenbaum); + jTextErgebnis.setText(String.valueOf(ergebnis)); + ausgabe += "\n=====================================\n\n"; + ausgabe += ta.alsString(rechenbaum); + } + jTextTree.setText(ausgabe); + } + catch(Exception x) + { + jTextTree.setText(x.getMessage()); + } + } + + private String baumAnzeigen(Binaerbaum b) + { + if (b == null) + { + return "(leerer Baum)"; + } + StringBuilder sb = new StringBuilder(); + sb.append(b.daten+"\n"); + if (b.links != null || b.rechts != null) + { + baumAnzeigen(b.links, "", true, sb); + baumAnzeigen(b.rechts, "", false, sb); + } + return sb.toString(); + } + + private void baumAnzeigen(Binaerbaum b, String indent, boolean left, StringBuilder sb) + { + sb.append(indent + (left ? "\u251C " : "\u2514 ")); + if (b != null) + { + sb.append(b.daten+"\n"); + if (b.links != null || b.rechts != null) + { + indent += (left ? "\u2502 " : " "); + baumAnzeigen(b.links, indent, true, sb); + baumAnzeigen(b.rechts, indent, false, sb); + } + } + else + { + sb.append("\n"); + } + } + +} diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/TermParser.java b/Quellcodes/Alg_DS_Terme/01_terme_roh/TermParser.java new file mode 100644 index 0000000..39a6464 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/TermParser.java @@ -0,0 +1,164 @@ +import java.util.ArrayList; +import java.util.Stack; + +/** + * Wandelt einen als String gegebenen Term in einen Rechenbaum um + * Hier sollte nichts verändert werden. + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class TermParser +{ + public static Binaerbaum parse(String term) throws Exception + { + ArrayList out = tokenizeTerm(term); + ArrayList postfix = buildPostfix(out); + Binaerbaum rechenbaum = buildTree(postfix); + return rechenbaum; + } + + private static Binaerbaum buildTree(ArrayList postfix) throws Exception + { + if (postfix.size() == 0) + { + return null; + } + Stack> stack = new Stack>(); + for (Symbol s : postfix) + { + if (s.istOperator()) + { + if (stack.size() < 2) + { + throw new Exception("Fehler: Zu viele Operatoren"); + } + Binaerbaum r = stack.pop(); + Binaerbaum l = stack.pop(); + Binaerbaum n = new Binaerbaum(s, l, r); + stack.push(n); + } + else + { + stack.push(new Binaerbaum(s)); + } + + } + if (stack.size() != 1) + { + throw new Exception("Fehler: Zu wenige Operatoren"); + } + return stack.pop(); + } + + private static ArrayList buildPostfix(ArrayList infix) throws Exception + { + Stack stack = new Stack(); + ArrayList postfix = new ArrayList(); + for(String token : infix) + { + if (isNumeric(token)) + { + postfix.add(new Symbol(token)); + } + else if (token.equals("(")) + { + stack.push(token); + } + else if (token.equals(")")) + { + while(true) + { + if (stack.isEmpty()) + { + throw new Exception("Fehler: Ungültiger Term."); + } + String t = stack.pop(); + if (t.equals("(")) + { + break; + } + postfix.add(new Symbol(t)); + } + } + else + { + while (!stack.isEmpty()) + { + String top = stack.peek(); + if ("+-*/".contains(top) && ("+-".contains(token) || "*/".contains(top))) + { + stack.pop(); + postfix.add(new Symbol(top)); + } + else + { + break; + } + } + stack.push(token); + } + } + while(!stack.isEmpty()) + { + String top = stack.pop(); + if (top.equals("(")) + { + throw new Exception("Fehler: Ungültig geklammerter Term"); + } + postfix.add(new Symbol(top)); + } + return postfix; + } + + private static boolean isNumeric(String s) + { + try + { + Integer.parseInt(s); + return true; + } + catch(Exception x) + { + } + return false; + } + + private static ArrayList tokenizeTerm(String strTerm) throws Exception + { + char[] term = strTerm.toCharArray(); + ArrayList tokens = new ArrayList(); + String numberToken = null; + for (char c : term) + { + if (Character.isDigit(c)) + { + if (numberToken == null) + numberToken = ""; + numberToken += String.valueOf(c); + } + else if ("+-*/()".contains(String.valueOf(c)) || Character.isWhitespace(c)) + { + if (numberToken != null) + { + tokens.add(numberToken); + numberToken = null; + } + if (!Character.isWhitespace(c)) + { + tokens.add(String.valueOf(c)); + } + } + else + { + throw new Exception("Fehler: Ungültige Zeichen in Term."); + } + } + if (numberToken != null) + { + tokens.add(numberToken); + } + return tokens; + } + +} diff --git a/Quellcodes/Alg_DS_Terme/01_terme_roh/package.bluej b/Quellcodes/Alg_DS_Terme/01_terme_roh/package.bluej new file mode 100644 index 0000000..f6debd9 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/01_terme_roh/package.bluej @@ -0,0 +1,122 @@ +#BlueJ package file +dependency1.from=AuswertungsTest +dependency1.to=Binaerbaum +dependency1.type=UsesDependency +dependency10.from=TermAuswerter +dependency10.to=Symbol +dependency10.type=UsesDependency +dependency11.from=TermFrame +dependency11.to=Binaerbaum +dependency11.type=UsesDependency +dependency12.from=TermFrame +dependency12.to=Symbol +dependency12.type=UsesDependency +dependency13.from=TermFrame +dependency13.to=TermAuswerter +dependency13.type=UsesDependency +dependency14.from=TermFrame +dependency14.to=TermParser +dependency14.type=UsesDependency +dependency15.from=TermParser +dependency15.to=Binaerbaum +dependency15.type=UsesDependency +dependency16.from=TermParser +dependency16.to=Symbol +dependency16.type=UsesDependency +dependency2.from=AuswertungsTest +dependency2.to=Symbol +dependency2.type=UsesDependency +dependency3.from=AuswertungsTest +dependency3.to=TermAuswerter +dependency3.type=UsesDependency +dependency4.from=AuswertungsTest +dependency4.to=TermParser +dependency4.type=UsesDependency +dependency5.from=AlsStringTest +dependency5.to=Binaerbaum +dependency5.type=UsesDependency +dependency6.from=AlsStringTest +dependency6.to=Symbol +dependency6.type=UsesDependency +dependency7.from=AlsStringTest +dependency7.to=TermAuswerter +dependency7.type=UsesDependency +dependency8.from=AlsStringTest +dependency8.to=TermParser +dependency8.type=UsesDependency +dependency9.from=TermAuswerter +dependency9.to=Binaerbaum +dependency9.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=925 +editor.fx.0.x=788 +editor.fx.0.y=67 +objectbench.height=92 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.846749226006192 +package.editor.height=540 +package.editor.width=649 +package.editor.x=80 +package.editor.y=86 +package.frame.height=746 +package.frame.width=800 +package.numDependencies=16 +package.numTargets=7 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=TermFrame +target1.showInterface=false +target1.type=ClassTarget +target1.width=100 +target1.x=70 +target1.y=130 +target2.height=50 +target2.name=Binaerbaum +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=150 +target2.y=10 +target3.height=50 +target3.name=Symbol +target3.showInterface=false +target3.type=ClassTarget +target3.width=80 +target3.x=220 +target3.y=200 +target4.height=50 +target4.name=AlsStringTest +target4.showInterface=false +target4.type=UnitTestTargetJunit4 +target4.width=110 +target4.x=280 +target4.y=350 +target5.height=50 +target5.name=AuswertungsTest +target5.showInterface=false +target5.type=UnitTestTargetJunit4 +target5.width=130 +target5.x=140 +target5.y=350 +target6.height=50 +target6.name=TermAuswerter +target6.showInterface=false +target6.type=ClassTarget +target6.width=120 +target6.x=410 +target6.y=240 +target7.height=50 +target7.name=TermParser +target7.showInterface=false +target7.type=ClassTarget +target7.width=100 +target7.x=330 +target7.y=70 diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/AlsStringTest.java b/Quellcodes/Alg_DS_Terme/02_terme_loes/AlsStringTest.java new file mode 100644 index 0000000..9b5c3a5 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/AlsStringTest.java @@ -0,0 +1,77 @@ +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Testet, ob die String-Umwandlung der Binärbäume korrekt funktioniert. + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class AlsStringTest +{ + @Test + public void test1() + { + testAusfuehren("2*3 + 4*5", "2*3+4*5"); + } + + @Test + public void test2() + { + testAusfuehren("(12/6) /2", "12/6/2"); + } + + @Test + public void test3() + { + testAusfuehren(" 12/(6/2)", "12/(6/2)"); + } + + @Test + public void test4() + { + testAusfuehren("(2+3)*(4 +5)", "(2+3)*(4+5)"); + } + + @Test + public void test5() + { + testAusfuehren("3/2+9/(3+1) ", "3/2+9/(3+1)"); + } + + @Test + public void test6() + { + testAusfuehren("100/5/(9-8)", "100/5/(9-8)"); + } + + @Test + public void test7() + { + testAusfuehren("1*2-3*4+(5*6)-7*8", "1*2-3*4+5*6-7*8"); + } + + @Test + public void test8() + { + testAusfuehren("(1*2+3*4)*((5*6)-7*(89/10))", "(1*2+3*4)*(5*6-7*89/10)"); + } + + private void testAusfuehren(String term, String erwartet) + { + try + { + Binaerbaum b = TermParser.parse(term); + TermAuswerter t = new TermAuswerter(); + String ergebnis = t.alsString(b); + assertEquals(erwartet, ergebnis.replaceAll("\\s", "")); + } + catch(Exception x) + { + assertTrue(x.getMessage(), false); + } + } + +} diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/AuswertungsTest.java b/Quellcodes/Alg_DS_Terme/02_terme_loes/AuswertungsTest.java new file mode 100644 index 0000000..831ac84 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/AuswertungsTest.java @@ -0,0 +1,77 @@ +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Testet, ob die Auswertung der Binärbäume korrekt funktioniert. + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class AuswertungsTest +{ + @Test + public void test1() + { + testAusfuehren("2*3+4*5", 26); + } + + @Test + public void test2() + { + testAusfuehren("(12/6)/2", 1); + } + + @Test + public void test3() + { + testAusfuehren("12/(6/2)", 4); + } + + @Test + public void test4() + { + testAusfuehren("(2+3)*(4+5)", 45); + } + + @Test + public void test5() + { + testAusfuehren("3/2+9/(3+1)", 3); + } + + @Test + public void test6() + { + testAusfuehren("100/5/(9-8)", 20); + } + + @Test + public void test7() + { + testAusfuehren("1*2-3*4+(5*6)-7*8", -36); + } + + @Test + public void test8() + { + testAusfuehren("(1*2+3*4)*((5*6)-7*(89/10))", -364); + } + + private void testAusfuehren(String term, int erwartet) + { + try + { + Binaerbaum b = TermParser.parse(term); + TermAuswerter t = new TermAuswerter(); + int ergebnis = t.auswerten(b); + assertEquals(erwartet, ergebnis); + } + catch(Exception x) + { + assertTrue(x.getMessage(), false); + } + } + +} diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/Binaerbaum.java b/Quellcodes/Alg_DS_Terme/02_terme_loes/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/README.TXT b/Quellcodes/Alg_DS_Terme/02_terme_loes/README.TXT new file mode 100644 index 0000000..f8b599a --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Terme +PROJEKTZWECK: Implementieren Sie das Auswerten von Rechentermen sowie das Umwandeln in eine String-Darstellung +VERSION oder DATUM: November 2020 +WIE IST DAS PROJEKT ZU STARTEN: Erzeugen Sie ein neues Objekt vom Typ TermFrame +AUTOR(EN): Rainer Helfrich, ZPG Informatik diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/Symbol.java b/Quellcodes/Alg_DS_Terme/02_terme_loes/Symbol.java new file mode 100644 index 0000000..ed5c157 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/Symbol.java @@ -0,0 +1,110 @@ + +/** + * Stellt ein Symbol eines Rechenterms dar. + * Frei nach der Abituraufgabe B3 von 2018 + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Symbol +{ + /** + * Der Operator bzw. der Wert des Symbols + */ + private String wert; + + /** + * Erzeugt ein neues Symbol. + * @param s Der Wert des Symbols + */ + public Symbol(String s) + { + wert = s; + } + + /** + * Gibt zurück, ob es sich bei dem Symbol um einen Operator handelt. + * @return true, wenn es ein Operator ist; false sonst + */ + public boolean istOperator() + { + return "+-*/".contains(wert); + } + + /** + * Gibt den Integer-Wert des Symbols zurück + * @return Den Integer-Wert des Symbols, wenn es sich um eine Zahl handelt; 0 sonst + */ + public int getInt() + { + if (!istOperator()) + { + return Integer.parseInt(wert); + } + return 0; + } + + /** + * Gibt zurück, ob es sich um einen Plus-Operator handelt + * @return true, wenn das Symbol "+" ist; false sonst + */ + public boolean istPlus() + { + return wert.equals("+"); + } + + /** + * Gibt zurück, ob es sich um einen Mal-Operator handelt + * @return true, wenn das Symbol "*" ist; false sonst + */ + public boolean istMal() + { + return wert.equals("*"); + } + + /** + * Gibt zurück, ob es sich um einen Minus-Operator handelt + * @return true, wenn das Symbol "-" ist; false sonst + */ + public boolean istMinus() + { + return wert.equals("-"); + } + + /** + * Gibt zurück, ob es sich um einen Geteilt-Operator handelt + * @return true, wenn das Symbol "/" ist; false sonst + */ + public boolean istGeteilt() + { + return wert.equals("/"); + } + + /** + * Gibt zurück, ob es sich um eine Punktrechnung handelt + * @return true, wenn das Symbol "*" oder "/" ist; false sonst + */ + public boolean istPunktRechnung() + { + return istMal() || istGeteilt(); + } + + /** + * Gibt zurück, ob es sich um eine Strichrechnung handelt + * @return true, wenn das Symbol "+" oder "-" ist; false sonst + */ + public boolean istStrichRechnung() + { + return istPlus() || istMinus(); + } + + /** + * Wandelt das Symbol in seine String-Darstellung um + * @return Die String-Darstellung des Symbols + */ + @Override + public String toString() + { + return wert; + } +} diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/TermAuswerter.java b/Quellcodes/Alg_DS_Terme/02_terme_loes/TermAuswerter.java new file mode 100644 index 0000000..35c9249 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/TermAuswerter.java @@ -0,0 +1,103 @@ + +/** + * Wertet einen Term aus, der als Rechenbaum gegeben ist + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class TermAuswerter +{ + /** + * Wertet den Term, der durch den Binärbaum b gegeben ist, arithmetisch aus + * @param b Der auszuwertende Baum + * @return Das Zahlergebnis des Terms + */ + public int auswerten(Binaerbaum b) + { + if (b.istBlatt()) + { + return b.daten.getInt(); + } + else + { + int l = auswerten(b.links); + int r = auswerten(b.rechts); + if (b.daten.istPlus()) + { + return l + r; + } + else if (b.daten.istMal()) + { + return l * r; + } + else if (b.daten.istMinus()) + { + return l - r; + } + else + { + return l / r; + } + } + } + + /** + * Wandelt den Term, der durch den Bin�rbaum b gegeben ist, in eine lineare Termdarstellung um + * @param b Der umzuwandelnde Term + * @return Der Term als lineare Zeichenkette + */ + private boolean brauchtKlammer(Binaerbaum b, boolean links) + { + Binaerbaum kind = links ? b.links : b.rechts; + if (kind.istBlatt()) + { + return false; + } + if (b.daten.istPunktRechnung()) + { + if (kind.daten.istStrichRechnung()) + return true; + if (!links && b.daten.istGeteilt()) + return true; + return false; + } + if (!links && b.daten.istMinus() && b.rechts.daten.istStrichRechnung()) + { + return true; + } + return false; + } + + public String alsString(Binaerbaum b) + { + if (b.istBlatt()) + { + return b.daten.toString(); + } + String ergebnis = ""; + + if (brauchtKlammer(b, true)) + { + ergebnis += "("; + } + ergebnis += alsString(b.links); + if (brauchtKlammer(b, true)) + { + ergebnis += ")"; + } + + ergebnis += b.daten.toString(); + + if (brauchtKlammer(b, false)) + { + ergebnis += "("; + } + ergebnis += alsString(b.rechts); + if (brauchtKlammer(b, false)) + { + ergebnis += ")"; + } + + return ergebnis; + } +} diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/TermFrame.java b/Quellcodes/Alg_DS_Terme/02_terme_loes/TermFrame.java new file mode 100644 index 0000000..dc06095 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/TermFrame.java @@ -0,0 +1,142 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.*; +import javax.swing.event.*; +/** + * + * GUI zum Verarbeiten von Termen + * Hier sollte nichts verändert werden. + * + * @version 1.0 vom 05.11.2020 + * @author Rainer Helfrich + */ + +public class TermFrame extends JFrame +{ + private JTextField jTextTerm = new JTextField(); + private JTextArea jTextTree = new JTextArea(""); + private JTextField jTextErgebnis = new JTextField(); + + public TermFrame() { + super(); + setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); + int frameWidth = 408; + int frameHeight = 580; + setSize(frameWidth, frameHeight); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + int x = (d.width - getSize().width) / 2; + int y = (d.height - getSize().height) / 2; + setLocation(x, y); + setTitle("Termauswertung"); + setResizable(true); + Container cp = getContentPane(); + cp.setLayout(null); + + jTextTerm.setBounds(96, 8, 289, 25); + jTextTerm.setFont(new Font("Courier New", Font.PLAIN, 12)); + cp.add(jTextTerm); + JScrollPane jTextArea1ScrollPane = new JScrollPane(jTextTree); + jTextArea1ScrollPane.setBounds(8, 40, 377, 465); + jTextTree.setEditable(false); + jTextTree.setFont(new Font("Courier New", Font.PLAIN, 12)); + cp.add(jTextArea1ScrollPane); + jTextErgebnis.setBounds(96, 512, 289, 25); + jTextErgebnis.setEditable(false); + jTextErgebnis.setFont(new Font("Courier New", Font.PLAIN, 12)); + cp.add(jTextErgebnis); + JLabel lErgebnis = new JLabel(); + lErgebnis.setBounds(8, 512, 78, 20); + lErgebnis.setText("Ergebnis:"); + cp.add(lErgebnis); + JLabel lTerm = new JLabel(); + lTerm.setBounds(8, 8, 78, 20); + lTerm.setText("Term:"); + cp.add(lTerm); + + jTextTerm.getDocument().addDocumentListener(new DocumentListener() { + public void changedUpdate(DocumentEvent e) { + parseTerm(); + } + + public void removeUpdate(DocumentEvent e) { + parseTerm(); + } + + public void insertUpdate(DocumentEvent e) { + parseTerm(); + } + + }); + addComponentListener(new ComponentAdapter() { + public void componentResized(ComponentEvent e) { + jTextArea1ScrollPane.setSize(getWidth()-31, getHeight()-115); + jTextErgebnis.setSize(getWidth()-119, 25); + jTextTerm.setSize(getWidth()-119, 25); + jTextErgebnis.setLocation(96, getHeight()-68); + lErgebnis.setLocation(8, getHeight()-68); + } + }); + setMinimumSize(new Dimension(300, 300)); + setVisible(true); + } + + private void parseTerm() + { + jTextTree.setText(""); + jTextErgebnis.setText(""); + try + { + Binaerbaum rechenbaum = TermParser.parse(jTextTerm.getText()); + String ausgabe = baumAnzeigen(rechenbaum); + if (rechenbaum != null) + { + TermAuswerter ta = new TermAuswerter(); + int ergebnis = ta.auswerten(rechenbaum); + jTextErgebnis.setText(String.valueOf(ergebnis)); + ausgabe += "\n=====================================\n\n"; + ausgabe += ta.alsString(rechenbaum); + } + jTextTree.setText(ausgabe); + } + catch(Exception x) + { + jTextTree.setText(x.getMessage()); + } + } + + private String baumAnzeigen(Binaerbaum b) + { + if (b == null) + { + return "(leerer Baum)"; + } + StringBuilder sb = new StringBuilder(); + sb.append(b.daten+"\n"); + if (b.links != null || b.rechts != null) + { + baumAnzeigen(b.links, "", true, sb); + baumAnzeigen(b.rechts, "", false, sb); + } + return sb.toString(); + } + + private void baumAnzeigen(Binaerbaum b, String indent, boolean left, StringBuilder sb) + { + sb.append(indent + (left ? "\u251C " : "\u2514 ")); + if (b != null) + { + sb.append(b.daten+"\n"); + if (b.links != null || b.rechts != null) + { + indent += (left ? "\u2502 " : " "); + baumAnzeigen(b.links, indent, true, sb); + baumAnzeigen(b.rechts, indent, false, sb); + } + } + else + { + sb.append("\n"); + } + } + +} diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/TermParser.java b/Quellcodes/Alg_DS_Terme/02_terme_loes/TermParser.java new file mode 100644 index 0000000..39a6464 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/TermParser.java @@ -0,0 +1,164 @@ +import java.util.ArrayList; +import java.util.Stack; + +/** + * Wandelt einen als String gegebenen Term in einen Rechenbaum um + * Hier sollte nichts verändert werden. + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class TermParser +{ + public static Binaerbaum parse(String term) throws Exception + { + ArrayList out = tokenizeTerm(term); + ArrayList postfix = buildPostfix(out); + Binaerbaum rechenbaum = buildTree(postfix); + return rechenbaum; + } + + private static Binaerbaum buildTree(ArrayList postfix) throws Exception + { + if (postfix.size() == 0) + { + return null; + } + Stack> stack = new Stack>(); + for (Symbol s : postfix) + { + if (s.istOperator()) + { + if (stack.size() < 2) + { + throw new Exception("Fehler: Zu viele Operatoren"); + } + Binaerbaum r = stack.pop(); + Binaerbaum l = stack.pop(); + Binaerbaum n = new Binaerbaum(s, l, r); + stack.push(n); + } + else + { + stack.push(new Binaerbaum(s)); + } + + } + if (stack.size() != 1) + { + throw new Exception("Fehler: Zu wenige Operatoren"); + } + return stack.pop(); + } + + private static ArrayList buildPostfix(ArrayList infix) throws Exception + { + Stack stack = new Stack(); + ArrayList postfix = new ArrayList(); + for(String token : infix) + { + if (isNumeric(token)) + { + postfix.add(new Symbol(token)); + } + else if (token.equals("(")) + { + stack.push(token); + } + else if (token.equals(")")) + { + while(true) + { + if (stack.isEmpty()) + { + throw new Exception("Fehler: Ungültiger Term."); + } + String t = stack.pop(); + if (t.equals("(")) + { + break; + } + postfix.add(new Symbol(t)); + } + } + else + { + while (!stack.isEmpty()) + { + String top = stack.peek(); + if ("+-*/".contains(top) && ("+-".contains(token) || "*/".contains(top))) + { + stack.pop(); + postfix.add(new Symbol(top)); + } + else + { + break; + } + } + stack.push(token); + } + } + while(!stack.isEmpty()) + { + String top = stack.pop(); + if (top.equals("(")) + { + throw new Exception("Fehler: Ungültig geklammerter Term"); + } + postfix.add(new Symbol(top)); + } + return postfix; + } + + private static boolean isNumeric(String s) + { + try + { + Integer.parseInt(s); + return true; + } + catch(Exception x) + { + } + return false; + } + + private static ArrayList tokenizeTerm(String strTerm) throws Exception + { + char[] term = strTerm.toCharArray(); + ArrayList tokens = new ArrayList(); + String numberToken = null; + for (char c : term) + { + if (Character.isDigit(c)) + { + if (numberToken == null) + numberToken = ""; + numberToken += String.valueOf(c); + } + else if ("+-*/()".contains(String.valueOf(c)) || Character.isWhitespace(c)) + { + if (numberToken != null) + { + tokens.add(numberToken); + numberToken = null; + } + if (!Character.isWhitespace(c)) + { + tokens.add(String.valueOf(c)); + } + } + else + { + throw new Exception("Fehler: Ungültige Zeichen in Term."); + } + } + if (numberToken != null) + { + tokens.add(numberToken); + } + return tokens; + } + +} diff --git a/Quellcodes/Alg_DS_Terme/02_terme_loes/package.bluej b/Quellcodes/Alg_DS_Terme/02_terme_loes/package.bluej new file mode 100644 index 0000000..44348b4 --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/02_terme_loes/package.bluej @@ -0,0 +1,122 @@ +#BlueJ package file +dependency1.from=TermFrame +dependency1.to=Binaerbaum +dependency1.type=UsesDependency +dependency10.from=AuswertungsTest +dependency10.to=Symbol +dependency10.type=UsesDependency +dependency11.from=AuswertungsTest +dependency11.to=TermAuswerter +dependency11.type=UsesDependency +dependency12.from=AuswertungsTest +dependency12.to=TermParser +dependency12.type=UsesDependency +dependency13.from=TermParser +dependency13.to=Binaerbaum +dependency13.type=UsesDependency +dependency14.from=TermParser +dependency14.to=Symbol +dependency14.type=UsesDependency +dependency15.from=TermAuswerter +dependency15.to=Binaerbaum +dependency15.type=UsesDependency +dependency16.from=TermAuswerter +dependency16.to=Symbol +dependency16.type=UsesDependency +dependency2.from=TermFrame +dependency2.to=Symbol +dependency2.type=UsesDependency +dependency3.from=TermFrame +dependency3.to=TermAuswerter +dependency3.type=UsesDependency +dependency4.from=TermFrame +dependency4.to=TermParser +dependency4.type=UsesDependency +dependency5.from=AlsStringTest +dependency5.to=Binaerbaum +dependency5.type=UsesDependency +dependency6.from=AlsStringTest +dependency6.to=Symbol +dependency6.type=UsesDependency +dependency7.from=AlsStringTest +dependency7.to=TermAuswerter +dependency7.type=UsesDependency +dependency8.from=AlsStringTest +dependency8.to=TermParser +dependency8.type=UsesDependency +dependency9.from=AuswertungsTest +dependency9.to=Binaerbaum +dependency9.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1201 +editor.fx.0.x=380 +editor.fx.0.y=62 +objectbench.height=94 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.8488023952095808 +package.editor.height=560 +package.editor.width=649 +package.editor.x=948 +package.editor.y=241 +package.frame.height=768 +package.frame.width=800 +package.numDependencies=16 +package.numTargets=7 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=TermFrame +target1.showInterface=false +target1.type=ClassTarget +target1.width=100 +target1.x=70 +target1.y=130 +target2.height=50 +target2.name=Binaerbaum +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=150 +target2.y=10 +target3.height=50 +target3.name=Symbol +target3.showInterface=false +target3.type=ClassTarget +target3.width=80 +target3.x=220 +target3.y=200 +target4.height=50 +target4.name=AlsStringTest +target4.showInterface=false +target4.type=UnitTestTargetJunit4 +target4.width=110 +target4.x=210 +target4.y=420 +target5.height=50 +target5.name=AuswertungsTest +target5.showInterface=false +target5.type=UnitTestTargetJunit4 +target5.width=130 +target5.x=430 +target5.y=160 +target6.height=50 +target6.name=TermAuswerter +target6.showInterface=false +target6.type=ClassTarget +target6.width=120 +target6.x=400 +target6.y=300 +target7.height=50 +target7.name=TermParser +target7.showInterface=false +target7.type=ClassTarget +target7.width=100 +target7.x=330 +target7.y=70 diff --git a/Quellcodes/Alg_DS_Terme/readme.adoc b/Quellcodes/Alg_DS_Terme/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Terme/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/.gitignore b/Quellcodes/Alg_DS_Tiefen_Breitensuche/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/01_tiefen_und_breitensuche_roh/BaumTester2.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/01_tiefen_und_breitensuche_roh/BaumTester2.java new file mode 100644 index 0000000..baa5633 --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/01_tiefen_und_breitensuche_roh/BaumTester2.java @@ -0,0 +1,13201 @@ +import static org.junit.Assert.*; +import org.junit.Test; + +/** + * Testet Tiefen- und Breitensuche + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class BaumTester2 +{ + @Test + public void testEnthaelt001() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(0)); + Integer e; + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(789, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(789, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(400, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(270, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(766, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(255, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(259, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(76, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(71, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(468, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + } + + @Test + public void testEnthaelt002() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(1)); + Integer e; + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(275, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(273, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(950, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(958, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(409, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(409, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(604, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(996, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(506, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(692, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(286, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(286, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(37, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.breitensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.tiefensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.breitensuche(x -> (x >= 160 && x < 170))); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(913, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(558, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(825, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + } + + @Test + public void testEnthaelt003() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(2)); + Integer e; + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(649, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(629, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(628, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(66, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(69, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(954, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(221, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(656, e.intValue()); + } + + @Test + public void testEnthaelt004() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(3)); + Integer e; + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(69, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(652, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(656, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(619, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(619, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(120, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(351, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(394, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(669, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(664, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(304, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(305, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(189, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(183, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + } + + @Test + public void testEnthaelt005() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(4)); + Integer e; + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(99, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(55, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(55, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(372, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(374, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.tiefensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.breitensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.tiefensuche(x -> (x >= 830 && x < 840))); + assertNull(ba.breitensuche(x -> (x >= 830 && x < 840))); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(581, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(586, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(134, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(133, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + } + + @Test + public void testEnthaelt006() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(5)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.breitensuche(x -> (x >= 640 && x < 650))); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(909, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.breitensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.tiefensuche(x -> (x >= 150 && x < 160))); + assertNull(ba.breitensuche(x -> (x >= 150 && x < 160))); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(624, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(624, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(780, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(787, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(601, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(601, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(423, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(757, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(373, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(372, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(74, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(865, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + } + + @Test + public void testEnthaelt007() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(6)); + Integer e; + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(599, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(645, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(642, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(496, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(625, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(606, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(606, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(182, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(181, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(908, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(990, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + } + + @Test + public void testEnthaelt008() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(7)); + Integer e; + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(259, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(452, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(568, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(296, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(293, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(897, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(897, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(572, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(574, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(13, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(14, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(202, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(165, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(677, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(677, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(224, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(224, e.intValue()); + } + + @Test + public void testEnthaelt009() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(8)); + Integer e; + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(531, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(75, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 520 && x < 530))); + assertNull(ba.breitensuche(x -> (x >= 520 && x < 530))); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(457, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(459, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(944, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(944, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.breitensuche(x -> (x >= 500 && x < 510))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(952, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(866, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(483, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(987, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(582, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(582, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(464, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(464, e.intValue()); + } + + @Test + public void testEnthaelt010() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(9)); + Integer e; + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 340 && x < 350))); + assertNull(ba.breitensuche(x -> (x >= 340 && x < 350))); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(296, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(293, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(848, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(757, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(88, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(88, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(939, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(360, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(411, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(805, e.intValue()); + } + + @Test + public void testEnthaelt011() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(10)); + Integer e; + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(170, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(170, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(478, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(922, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(197, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(835, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(839, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(971, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(238, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(690, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 510 && x < 520))); + assertNull(ba.breitensuche(x -> (x >= 510 && x < 520))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.breitensuche(x -> (x >= 160 && x < 170))); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.breitensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + } + + @Test + public void testEnthaelt012() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(11)); + Integer e; + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(563, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(563, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(92, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(114, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(917, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(917, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(621, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(628, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.breitensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + } + + @Test + public void testEnthaelt013() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(12)); + Integer e; + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(279, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(273, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(611, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(124, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(124, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 380 && x < 390))); + assertNull(ba.breitensuche(x -> (x >= 380 && x < 390))); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.breitensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(782, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(911, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(91, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(91, e.intValue()); + } + + @Test + public void testEnthaelt014() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(13)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(106, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(106, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(902, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(291, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(517, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(943, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(940, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + } + + @Test + public void testEnthaelt015() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(14)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(888, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(257, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(255, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(518, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(21, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(20, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(99, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(92, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(776, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(123, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(31, e.intValue()); + } + + @Test + public void testEnthaelt016() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(15)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.breitensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(342, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(342, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(52, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(52, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(636, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(636, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(730, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(730, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(591, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(152, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(152, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(310, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(426, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(121, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(762, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(856, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(723, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(231, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(775, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + } + + @Test + public void testEnthaelt017() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(16)); + Integer e; + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.breitensuche(x -> (x >= 500 && x < 510))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(783, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(806, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(115, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.breitensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(103, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(107, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(357, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + } + + @Test + public void testEnthaelt018() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(17)); + Integer e; + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(974, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(180, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(180, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(231, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(825, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(651, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(136, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(132, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(922, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(885, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(885, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(378, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(378, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(440, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(440, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.tiefensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.breitensuche(x -> (x >= 400 && x < 410))); + } + + @Test + public void testEnthaelt019() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(18)); + Integer e; + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(3, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(3, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(431, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(431, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(325, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(329, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(647, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + + assertEquals(222, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(238, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(238, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(290, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(574, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(47, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(637, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(195, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.breitensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.tiefensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.breitensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.tiefensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.breitensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.tiefensuche(x -> (x >= 510 && x < 520))); + assertNull(ba.breitensuche(x -> (x >= 510 && x < 520))); + } + + @Test + public void testEnthaelt020() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(19)); + Integer e; + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(758, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(758, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(931, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(931, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(187, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(187, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(791, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(791, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(14, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(765, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(522, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(528, e.intValue()); + } + + @Test + public void testEnthaelt021() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(20)); + Integer e; + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(971, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(971, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(395, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(196, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(192, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(850, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(586, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(584, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + } + + @Test + public void testEnthaelt022() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(21)); + Integer e; + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(19, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(666, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(666, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(320, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(320, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(382, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(692, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(693, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(261, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(267, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(674, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(674, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(68, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(68, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(975, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.breitensuche(x -> (x >= 50 && x < 60))); + } + + @Test + public void testEnthaelt023() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(22)); + Integer e; + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(266, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(190, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(413, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.breitensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(950, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(913, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(609, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(677, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(662, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(47, e.intValue()); + } + + @Test + public void testEnthaelt024() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(23)); + Integer e; + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(953, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(953, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(67, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(700, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 850 && x < 860))); + assertNull(ba.breitensuche(x -> (x >= 850 && x < 860))); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(882, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.breitensuche(x -> (x >= 730 && x < 740))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(248, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(802, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(805, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + } + + @Test + public void testEnthaelt025() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(24)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 30 && x < 40))); + assertNull(ba.breitensuche(x -> (x >= 30 && x < 40))); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(211, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(211, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(507, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(296, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(949, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(692, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(782, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + } + + @Test + public void testEnthaelt026() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(25)); + Integer e; + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(684, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(684, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(652, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(652, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(948, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(948, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(876, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(264, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(393, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(507, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.breitensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.tiefensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.breitensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.tiefensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.breitensuche(x -> (x >= 50 && x < 60))); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(861, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(860, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + } + + @Test + public void testEnthaelt027() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(26)); + Integer e; + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(443, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(460, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(460, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(67, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(68, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(310, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(310, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(584, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(581, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(403, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(403, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 20 && x < 30))); + assertNull(ba.breitensuche(x -> (x >= 20 && x < 30))); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(673, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(673, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(284, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(281, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(934, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + } + + @Test + public void testEnthaelt028() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(27)); + Integer e; + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(321, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(321, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(976, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(978, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(707, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(221, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(745, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(204, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.breitensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(169, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + } + + @Test + public void testEnthaelt029() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(28)); + Integer e; + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(549, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(59, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(59, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(137, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(137, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(503, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(818, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + } + + @Test + public void testEnthaelt030() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(29)); + Integer e; + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(242, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(910, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(910, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(700, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(848, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(841, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(10, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(14, e.intValue()); + } + + @Test + public void testEnthaelt031() + { + + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(30)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(427, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(427, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 240 && x < 250))); + assertNull(ba.breitensuche(x -> (x >= 240 && x < 250))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(287, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(287, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(957, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(953, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(115, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(660, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(91, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(689, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(908, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(41, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(888, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + } + + @Test + public void testEnthaelt032() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(31)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.breitensuche(x -> (x >= 470 && x < 480))); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(625, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(625, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(306, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(800, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(800, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.tiefensuche(x -> (x >= 830 && x < 840))); + assertNull(ba.breitensuche(x -> (x >= 830 && x < 840))); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(111, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(443, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(949, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(642, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(547, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + } + + @Test + public void testEnthaelt033() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(32)); + Integer e; + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(37, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(34, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(317, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(114, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(239, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(431, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(152, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(421, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(421, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + } + + @Test + public void testEnthaelt034() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(33)); + Integer e; + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(132, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(132, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.breitensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 510 && x < 520))); + assertNull(ba.breitensuche(x -> (x >= 510 && x < 520))); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(107, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(107, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(195, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(192, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(771, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(771, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(957, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(21, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(581, e.intValue()); + } + + @Test + public void testEnthaelt035() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(34)); + Integer e; + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(58, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(781, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(661, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + } + + @Test + public void testEnthaelt036() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(35)); + Integer e; + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(846, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(846, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(859, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(915, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(915, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.breitensuche(x -> (x >= 100 && x < 110))); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(326, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(321, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(546, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(546, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(516, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(929, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(28, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(23, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(93, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + } + + @Test + public void testEnthaelt037() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(36)); + Integer e; + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(579, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(65, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(826, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(826, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(83, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(201, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + } + + @Test + public void testEnthaelt038() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(37)); + Integer e; + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(980, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(5, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(751, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(133, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(255, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(740, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(743, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.breitensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + } + + @Test + public void testEnthaelt039() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(38)); + Integer e; + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(609, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(35, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(35, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(592, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.breitensuche(x -> (x >= 960 && x < 970))); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(304, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 360 && x < 370))); + assertNull(ba.breitensuche(x -> (x >= 360 && x < 370))); + assertNull(ba.tiefensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.breitensuche(x -> (x >= 540 && x < 550))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(789, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(353, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(357, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(426, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(422, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(146, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + } + + @Test + public void testEnthaelt040() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(39)); + Integer e; + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(13, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(13, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(614, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(615, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(462, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(792, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(621, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(168, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(809, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(806, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(710, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(710, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(683, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(683, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(992, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(90, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(90, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + } + + @Test + public void testEnthaelt041() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(40)); + Integer e; + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(25, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(25, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(199, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(689, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(587, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(587, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.tiefensuche(x -> (x >= 360 && x < 370))); + assertNull(ba.breitensuche(x -> (x >= 360 && x < 370))); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(980, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(980, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(730, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(290, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(700, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(403, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(345, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(413, e.intValue()); + } + + @Test + public void testEnthaelt042() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(41)); + Integer e; + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(378, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(552, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(552, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.breitensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.tiefensuche(x -> (x >= 410 && x < 420))); + assertNull(ba.breitensuche(x -> (x >= 410 && x < 420))); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(236, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(825, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(461, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(464, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(928, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(387, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(765, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + } + + @Test + public void testEnthaelt043() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(42)); + Integer e; + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(998, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(998, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(467, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(467, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(628, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 800 && x < 810))); + assertNull(ba.breitensuche(x -> (x >= 800 && x < 810))); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(478, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(675, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(838, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(838, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(78, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(78, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(353, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(236, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 0 && x < 10))); + assertNull(ba.breitensuche(x -> (x >= 0 && x < 10))); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + } + + @Test + public void testEnthaelt044() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(43)); + Integer e; + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(499, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(499, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(517, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(40, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(47, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(756, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(751, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(58, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(51, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(801, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + } + + @Test + public void testEnthaelt045() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(44)); + Integer e; + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(661, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(664, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(937, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(74, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(479, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(42, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(41, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(752, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(752, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(622, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(729, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(729, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + } + + @Test + public void testEnthaelt046() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(45)); + Integer e; + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(880, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(880, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(526, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(545, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(584, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(457, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(732, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(879, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(78, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(320, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 420 && x < 430))); + assertNull(ba.breitensuche(x -> (x >= 420 && x < 430))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(472, e.intValue()); + } + + @Test + public void testEnthaelt047() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(46)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(178, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(175, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(299, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(299, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(528, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(528, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(636, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(630, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(23, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(748, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(866, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(860, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(199, e.intValue()); + } + + @Test + public void testEnthaelt048() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(47)); + Integer e; + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(484, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(922, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 150 && x < 160))); + assertNull(ba.breitensuche(x -> (x >= 150 && x < 160))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(835, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(835, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(944, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(940, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(221, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(19, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(719, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(719, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(776, e.intValue()); + } + + @Test + public void testEnthaelt049() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(48)); + Integer e; + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(137, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(716, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(713, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(347, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(341, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(382, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(66, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(240, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(359, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(359, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(888, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(886, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(436, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(893, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(893, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + } + + @Test + public void testEnthaelt050() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(49)); + Integer e; + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(168, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.tiefensuche(x -> (x >= 680 && x < 690))); + assertNull(ba.breitensuche(x -> (x >= 680 && x < 690))); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(123, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(123, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(568, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(567, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(133, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(139, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(503, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(143, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(148, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(656, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + } + + @Test + public void testEnthaelt051() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(50)); + Integer e; + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(937, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(937, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(911, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(911, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(204, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(204, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.breitensuche(x -> (x >= 940 && x < 950))); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(301, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(301, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(891, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(90, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(97, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(607, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(843, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(329, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(326, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(967, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + } + + @Test + public void testEnthaelt052() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(51)); + Integer e; + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(120, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(188, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(666, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(579, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(826, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(89, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(791, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(950, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + } + + @Test + public void testEnthaelt053() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(52)); + Integer e; + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(740, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(743, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(247, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(247, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(400, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(108, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(108, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(468, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(393, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(393, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(494, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(585, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(585, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + } + + @Test + public void testEnthaelt054() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(53)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.breitensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(264, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(264, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(126, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(126, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(795, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(795, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(861, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 310 && x < 320))); + assertNull(ba.breitensuche(x -> (x >= 310 && x < 320))); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(233, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(233, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(497, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(112, e.intValue()); + } + + @Test + public void testEnthaelt055() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(54)); + Integer e; + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(872, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(872, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(599, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(918, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(915, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(315, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(507, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(504, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(279, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.tiefensuche(x -> (x >= 30 && x < 40))); + assertNull(ba.breitensuche(x -> (x >= 30 && x < 40))); + } + + @Test + public void testEnthaelt056() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(55)); + Integer e; + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.breitensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(54, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(54, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(476, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(411, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(69, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 870 && x < 880))); + assertNull(ba.breitensuche(x -> (x >= 870 && x < 880))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(859, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(859, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(806, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(355, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(355, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + } + + @Test + public void testEnthaelt057() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(56)); + Integer e; + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(619, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(891, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(531, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(535, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(428, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(426, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(762, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(108, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(974, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(975, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(116, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(116, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + } + + @Test + public void testEnthaelt058() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(57)); + Integer e; + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(727, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(315, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(419, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(291, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(987, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + } + + @Test + public void testEnthaelt059() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(58)); + Integer e; + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(708, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(954, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(957, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(891, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(197, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(196, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(610, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(610, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(518, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(778, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(724, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(726, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(53, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + } + + @Test + public void testEnthaelt060() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(59)); + Integer e; + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(719, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(900, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(900, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(148, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(148, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(195, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(624, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(462, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(462, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(8, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(8, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(771, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.tiefensuche(x -> (x >= 800 && x < 810))); + assertNull(ba.breitensuche(x -> (x >= 800 && x < 810))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(81, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(89, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(452, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 40 && x < 50))); + assertNull(ba.breitensuche(x -> (x >= 40 && x < 50))); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + } + + @Test + public void testEnthaelt061() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(60)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.breitensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 340 && x < 350))); + assertNull(ba.breitensuche(x -> (x >= 340 && x < 350))); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(494, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(494, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(958, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(690, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(690, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(201, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(630, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(878, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(370, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(376, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + } + + @Test + public void testEnthaelt062() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(61)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 590 && x < 600))); + assertNull(ba.breitensuche(x -> (x >= 590 && x < 600))); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.tiefensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.breitensuche(x -> (x >= 650 && x < 660))); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(681, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(681, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(989, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(989, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(809, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(809, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(579, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(317, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(836, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(836, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(75, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(330, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(169, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(260, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + } + + @Test + public void testEnthaelt063() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(62)); + Integer e; + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(932, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(932, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(766, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(820, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(820, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(567, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(567, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(836, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(839, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(552, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(958, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(940, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(682, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(295, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(297, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.tiefensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.breitensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.tiefensuche(x -> (x >= 980 && x < 990))); + assertNull(ba.breitensuche(x -> (x >= 980 && x < 990))); + } + + @Test + public void testEnthaelt064() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(63)); + Integer e; + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.breitensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.tiefensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.breitensuche(x -> (x >= 880 && x < 890))); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 700 && x < 710))); + assertNull(ba.breitensuche(x -> (x >= 700 && x < 710))); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(838, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(242, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(242, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(112, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(116, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(308, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(607, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(35, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(38, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(800, e.intValue()); + } + + @Test + public void testEnthaelt065() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(64)); + Integer e; + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(591, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(315, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(120, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(934, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(300, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(781, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(787, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(870, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(445, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(445, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + } + + @Test + public void testEnthaelt066() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(65)); + Integer e; + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.tiefensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.breitensuche(x -> (x >= 350 && x < 360))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(696, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(696, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(517, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(228, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(500, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(509, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(472, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(330, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(778, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(820, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + } + + @Test + public void testEnthaelt067() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(66)); + Integer e; + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 740 && x < 750))); + assertNull(ba.breitensuche(x -> (x >= 740 && x < 750))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(277, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.breitensuche(x -> (x >= 400 && x < 410))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(695, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(693, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(351, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.breitensuche(x -> (x >= 650 && x < 660))); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(451, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(931, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(181, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(174, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(503, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + } + + @Test + public void testEnthaelt068() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(67)); + Integer e; + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(850, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(182, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(182, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(670, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(670, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(372, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(89, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(873, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(796, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + } + + @Test + public void testEnthaelt069() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(68)); + Integer e; + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(158, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(531, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(483, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(484, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(701, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(701, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(227, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(256, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(251, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(114, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(802, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + } + + @Test + public void testEnthaelt070() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(69)); + Integer e; + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(908, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(280, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(549, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(422, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(895, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + } + + @Test + public void testEnthaelt071() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(70)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.breitensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(682, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(259, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(38, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(775, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(360, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(360, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(267, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(269, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(235, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(353, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + } + + @Test + public void testEnthaelt072() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(71)); + Integer e; + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(928, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(928, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(801, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(801, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(816, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.tiefensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.breitensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.tiefensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.breitensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.tiefensuche(x -> (x >= 420 && x < 430))); + assertNull(ba.breitensuche(x -> (x >= 420 && x < 430))); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(913, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(41, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(160, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(363, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(75, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(71, e.intValue()); + } + + @Test + public void testEnthaelt073() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(72)); + Integer e; + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(526, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(467, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(816, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(661, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(662, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.breitensuche(x -> (x >= 100 && x < 110))); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(932, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(939, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(902, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(902, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(375, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(506, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(500, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + } + + @Test + public void testEnthaelt074() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(73)); + Integer e; + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(982, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(509, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.breitensuche(x -> (x >= 580 && x < 590))); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(604, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(850, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(949, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(205, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(205, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + } + + @Test + public void testEnthaelt075() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(74)); + Integer e; + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(10, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(10, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(748, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.breitensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.tiefensuche(x -> (x >= 420 && x < 430))); + assertNull(ba.breitensuche(x -> (x >= 420 && x < 430))); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(284, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(284, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(776, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(155, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + } + + @Test + public void testEnthaelt076() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(75)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 240 && x < 250))); + assertNull(ba.breitensuche(x -> (x >= 240 && x < 250))); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(419, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(419, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.tiefensuche(x -> (x >= 700 && x < 710))); + assertNull(ba.breitensuche(x -> (x >= 700 && x < 710))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(614, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(614, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(956, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(956, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(929, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(660, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(664, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + } + + @Test + public void testEnthaelt077() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(76)); + Integer e; + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(563, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(42, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(40, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(998, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(992, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(52, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(58, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(591, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(16, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(16, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(522, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(461, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(461, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(457, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(651, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.breitensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.tiefensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.breitensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + } + + @Test + public void testEnthaelt078() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(77)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(300, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(483, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(65, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(65, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(878, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(870, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(615, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(766, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(211, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.breitensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.tiefensuche(x -> (x >= 850 && x < 860))); + assertNull(ba.breitensuche(x -> (x >= 850 && x < 860))); + } + + @Test + public void testEnthaelt079() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(78)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.breitensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.tiefensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.breitensuche(x -> (x >= 730 && x < 740))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(444, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(444, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(327, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(326, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(348, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(348, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(831, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(831, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(716, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(716, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(436, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(436, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(796, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(32, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(32, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(415, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(497, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(287, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + } + + @Test + public void testEnthaelt080() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(79)); + Integer e; + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(792, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(917, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(31, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(248, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(248, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(374, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(373, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(511, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(511, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(934, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(941, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(218, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(295, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.breitensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.tiefensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.breitensuche(x -> (x >= 350 && x < 360))); + } + + @Test + public void testEnthaelt081() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(80)); + Integer e; + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(694, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(975, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(387, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(765, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(982, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(455, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(206, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(206, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(930, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(930, e.intValue()); + } + + @Test + public void testEnthaelt082() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(81)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(432, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(432, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(227, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(227, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(876, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(876, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 240 && x < 250))); + assertNull(ba.breitensuche(x -> (x >= 240 && x < 250))); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(143, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(599, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(592, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(841, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(844, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(174, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(178, e.intValue()); + } + + @Test + public void testEnthaelt083() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(82)); + Integer e; + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(681, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(330, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(176, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(176, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(872, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(12, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(77, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(77, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(96, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(96, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.breitensuche(x -> (x >= 640 && x < 650))); + } + + @Test + public void testEnthaelt084() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(83)); + Integer e; + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(604, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(111, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(823, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(823, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(136, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(136, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(694, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(694, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(535, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(535, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(918, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(627, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.breitensuche(x -> (x >= 320 && x < 330))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(780, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(787, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(277, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(279, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.breitensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.tiefensuche(x -> (x >= 990 && x < 1000))); + assertNull(ba.breitensuche(x -> (x >= 990 && x < 1000))); + assertNull(ba.tiefensuche(x -> (x >= 410 && x < 420))); + assertNull(ba.breitensuche(x -> (x >= 410 && x < 420))); + } + + @Test + public void testEnthaelt085() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(84)); + Integer e; + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(622, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.tiefensuche(x -> (x >= 740 && x < 750))); + assertNull(ba.breitensuche(x -> (x >= 740 && x < 750))); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(235, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(235, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(444, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(989, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(696, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(359, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + } + + @Test + public void testEnthaelt086() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(85)); + Integer e; + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(421, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(961, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(961, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(522, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(129, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(129, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(275, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(275, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(304, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(751, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(206, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + } + + @Test + public void testEnthaelt087() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(86)); + Integer e; + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.tiefensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.breitensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(184, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(184, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(796, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(280, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(280, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(735, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + } + + @Test + public void testEnthaelt088() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(87)); + Integer e; + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(693, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(423, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(669, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(668, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(387, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(342, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(233, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(440, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(368, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(368, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + } + + @Test + public void testEnthaelt089() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(88)); + Integer e; + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(873, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(873, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(178, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(327, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(479, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(479, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(155, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 910 && x < 920))); + assertNull(ba.breitensuche(x -> (x >= 910 && x < 920))); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(112, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(96, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(395, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + } + + @Test + public void testEnthaelt090() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(89)); + Integer e; + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.breitensuche(x -> (x >= 540 && x < 550))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 430 && x < 440))); + assertNull(ba.breitensuche(x -> (x >= 430 && x < 440))); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(131, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(578, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(578, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(511, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(516, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(213, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(756, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(756, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(609, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + } + + @Test + public void testEnthaelt091() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(90)); + Integer e; + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(863, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(978, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(76, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(508, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(668, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(246, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(246, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(695, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(695, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(50, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(50, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + } + + @Test + public void testEnthaelt092() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(91)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(420, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(420, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(266, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(266, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(819, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(726, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(99, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(92, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(21, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(651, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + } + + @Test + public void testEnthaelt093() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(92)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 910 && x < 920))); + assertNull(ba.breitensuche(x -> (x >= 910 && x < 920))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(396, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(396, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(518, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(574, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(256, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(257, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(102, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(954, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(115, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + } + + @Test + public void testEnthaelt094() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(93)); + Integer e; + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(708, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.breitensuche(x -> (x >= 960 && x < 970))); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(323, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(323, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(270, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(270, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(816, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.breitensuche(x -> (x >= 470 && x < 480))); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(363, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(363, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 430 && x < 440))); + assertNull(ba.breitensuche(x -> (x >= 430 && x < 440))); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(155, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(726, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(684, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(113, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(111, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(374, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(375, e.intValue()); + } + + @Test + public void testEnthaelt095() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(94)); + Integer e; + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(16, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(732, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(251, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(251, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(262, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(207, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + } + + @Test + public void testEnthaelt096() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(95)); + Integer e; + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(927, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(927, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(865, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(865, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(256, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(537, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + } + + @Test + public void testEnthaelt097() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(96)); + Integer e; + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(910, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(918, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.breitensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(982, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(261, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(261, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(723, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(158, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(708, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(160, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(347, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(341, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(870, e.intValue()); + } + + @Test + public void testEnthaelt098() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(97)); + Integer e; + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(555, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(555, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.breitensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(895, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(895, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(986, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(592, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(611, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(611, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(34, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(637, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(201, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + } + + @Test + public void testEnthaelt099() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(98)); + Integer e; + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(207, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(327, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(970, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(970, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(37, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(927, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(929, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(568, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + } + + @Test + public void testEnthaelt100() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(99)); + Integer e; + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(752, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.breitensuche(x -> (x >= 450 && x < 460))); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(411, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(601, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(351, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(846, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(396, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(121, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(231, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(5, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + } + +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/01_tiefen_und_breitensuche_roh/Baumalgorithmen2.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/01_tiefen_und_breitensuche_roh/Baumalgorithmen2.java new file mode 100644 index 0000000..387054e --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/01_tiefen_und_breitensuche_roh/Baumalgorithmen2.java @@ -0,0 +1,41 @@ +import java.util.function.Predicate; + +/** + * Tiefen- und Breitensuche + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Baumalgorithmen2 extends Baumalgorithmen +{ + /** + * Erzeugt ein neues Algorithmen-Objekt + * @param wurzel Die Wurzel des Baums, der verarbeitet werden soll + */ + public Baumalgorithmen2(Binaerbaum wurzel) + { + super(wurzel); + } + + /** + * Sucht mit der Breitensuche den ersten Knoten, der das Prädikat erfüllt + * @param p Das Prädikat, das erfüllt werden soll. + * @return Der Wert, der das Prädikat erfüllt + */ + public Integer breitensuche(Predicate p) + { + //# TODO: Implementieren Sie die Breitensuche wie beschrieben + return null; + } + + /** + * Sucht mit der Breitensuche den ersten Knoten, der das Prädikat erfüllt + * @param p Das Prädikat, das erfüllt werden soll. + * @return Der Wert, der das Prädikat erfüllt + */ + public Integer tiefensuche(Predicate p) + { + //# TODO: Implementieren Sie die Tiefensuche wie beschrieben + return null; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/ArrayQueue.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/ArrayQueue.java new file mode 100644 index 0000000..c34e0cd --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/ArrayQueue.java @@ -0,0 +1,124 @@ + +/** + * Queue basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayQueue extends Queue +{ + /** + * Die Nutzdaten + */ + private Object[] daten; + + /** + * Der Index des ersten Wertes + */ + private int first; + + /** + * Der nächste freie Index + */ + private int last; + + /** + * Erzeugt eine neue, leere Queue + */ + public ArrayQueue() + { + daten = new Object[10]; + first = 0; + last = 0; + } + + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public void enqueue(T x) + { + daten[last] = x; + last++; + if (last == daten.length) + { + last = 0; + } + if (last == first) // Vergrößerung nötig + { + Object[] tmp = new Object[daten.length*2]; + System.arraycopy(daten, first, tmp, 0, daten.length - first); + System.arraycopy(daten, 0, tmp, daten.length - first, first); + first = 0; + last = daten.length; + daten = tmp; + } + } + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public T front() + { + if (isEmpty()) + { + return null; + } + return (T)daten[first]; + } + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public T dequeue() + { + T x = null; + if (!isEmpty()) + { + x = (T)daten[first]; + first++; + if (first == daten.length) + { + first = 0; + } + } + return x; + } + + /** + * Gibt zurück, ob die Queue leer ist + * @return true, wenn die Queue leer ist; false sonst + */ + public boolean isEmpty() + { + return first == last; + } + + /** + * Gibt die Queue in String-Form aus. + * @return Die String-Repräsentation der Queue + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + for (int i = first; i < (last < first ? daten.length : last); i++) + { + if (i != first) + { + b.append(", "); + } + b.append(daten[i]); + } + if (last < first) + { + for (int i = 0; i < last; i++) + { + b.append(", " + daten[i]); + } + } + return "< " + b.toString() + " <"; + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/ArrayStack.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/ArrayStack.java new file mode 100644 index 0000000..dbcc08b --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/ArrayStack.java @@ -0,0 +1,101 @@ + +/** + * Ein Stack basierend auf einem Array + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ArrayStack extends Stack +{ + /** + * Enthält die Nutzdaten + */ + private Object[] daten; + /** + * Die Zahl gibt an, wie viele Elemente auf dem Stack liegen und damit auch, + * wie viele Werte im Datenarray gültig sind. + */ + private int anzahl; + + /** + * Erzeugt einen neuen leeren Stack + */ + public ArrayStack() + { + daten = new Object[10]; + anzahl = 0; + } + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public T top() + { + if (!isEmpty()) + { + return (T)daten[anzahl-1]; + } + return null; + } + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public T pop() + { + if (!isEmpty()) + { + anzahl--; + return (T)daten[anzahl]; + } + return null; + } + + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public void push(T wert) + { + if (anzahl == daten.length) + { + Object[] tmp = new Object[2*daten.length]; + System.arraycopy(daten, 0, tmp, 0, daten.length); + daten = tmp; + } + daten[anzahl] = wert; + anzahl++; + } + + /** + * Gibt zurück, ob der Stack leer ist + * @return true, wenn der Stack leer ist; false sonst + */ + public boolean isEmpty() + { + return anzahl == 0; + } + + /** + * Gibt den Stack in String-Form aus. + * @return Die String-Repräsentation des Stacks + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + b.append("[ "); + for (int i = 0; i < anzahl; i++) + { + if (i > 0) + { + b.append(", "); + } + b.append(daten[i]); + } + b.append(" <"); + return b.toString(); + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/BaumTester.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/BaumTester.java new file mode 100644 index 0000000..ce524bd --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/BaumTester.java @@ -0,0 +1,2819 @@ +import static org.junit.Assert.*; +import org.junit.Test; + +/** + * Eine Testklasse für Baumalgorithmen + * + * @author Rainer Helfrich + * @version 02.11.2020 + */ +public class BaumTester +{ + @Test + public void test001() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(0)); + assertEquals(481,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(512)); + assertTrue(ba.enthaelt(596)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(510)); + assertFalse(ba.enthaelt(554)); + assertFalse(ba.enthaelt(287)); + assertFalse(ba.enthaelt(99)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(875)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(974)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(146)); + assertTrue(ba.enthaelt(366)); + assertTrue(ba.enthaelt(367)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(175)); + } + + @Test + public void test002() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(1)); + assertEquals(183,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(711)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(637)); + assertFalse(ba.enthaelt(888)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(692)); + assertTrue(ba.enthaelt(731)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(667)); + assertFalse(ba.enthaelt(549)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(825)); + assertTrue(ba.enthaelt(592)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(416)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(388)); + } + + @Test + public void test003() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(2)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(985)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(374)); + assertFalse(ba.enthaelt(304)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(67)); + assertFalse(ba.enthaelt(972)); + assertFalse(ba.enthaelt(384)); + assertFalse(ba.enthaelt(845)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(353)); + assertTrue(ba.enthaelt(656)); + assertTrue(ba.enthaelt(207)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(163)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(69)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(189)); + } + + @Test + public void test004() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(3)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(132)); + assertFalse(ba.enthaelt(921)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(395)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(141)); + assertTrue(ba.enthaelt(523)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(315)); + assertTrue(ba.enthaelt(849)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(666)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(76)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(585)); + } + + @Test + public void test005() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(4)); + assertEquals(133,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(13)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(236)); + assertFalse(ba.enthaelt(468)); + assertTrue(ba.enthaelt(428)); + assertFalse(ba.enthaelt(312)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(854)); + assertTrue(ba.enthaelt(657)); + assertTrue(ba.enthaelt(232)); + assertTrue(ba.enthaelt(659)); + assertTrue(ba.enthaelt(55)); + assertTrue(ba.enthaelt(598)); + assertTrue(ba.enthaelt(127)); + } + + @Test + public void test006() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(5)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(243)); + assertFalse(ba.enthaelt(248)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(285)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(187)); + assertTrue(ba.enthaelt(4)); + assertFalse(ba.enthaelt(497)); + assertTrue(ba.enthaelt(983)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(47)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(116)); + assertTrue(ba.enthaelt(287)); + assertTrue(ba.enthaelt(423)); + assertTrue(ba.enthaelt(165)); + assertTrue(ba.enthaelt(905)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(985)); + } + + @Test + public void test007() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(6)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(452)); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(849)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(610)); + assertFalse(ba.enthaelt(73)); + assertTrue(ba.enthaelt(472)); + assertFalse(ba.enthaelt(603)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(704)); + assertTrue(ba.enthaelt(828)); + assertTrue(ba.enthaelt(178)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(341)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(916)); + assertTrue(ba.enthaelt(227)); + } + + @Test + public void test008() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(7)); + assertEquals(389,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(772)); + assertFalse(ba.enthaelt(426)); + assertFalse(ba.enthaelt(953)); + assertTrue(ba.enthaelt(319)); + assertFalse(ba.enthaelt(467)); + assertFalse(ba.enthaelt(417)); + assertTrue(ba.enthaelt(883)); + assertTrue(ba.enthaelt(657)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(80)); + assertFalse(ba.enthaelt(183)); + assertFalse(ba.enthaelt(318)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(412)); + assertFalse(ba.enthaelt(145)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(572)); + assertTrue(ba.enthaelt(208)); + } + + @Test + public void test009() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(8)); + assertEquals(159,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(746)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(850)); + assertFalse(ba.enthaelt(267)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(1009)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(166)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(25)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(709)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(853)); + assertTrue(ba.enthaelt(628)); + assertTrue(ba.enthaelt(202)); + } + + @Test + public void test010() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(9)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(993)); + assertTrue(ba.enthaelt(904)); + assertFalse(ba.enthaelt(211)); + assertTrue(ba.enthaelt(845)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(544)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(852)); + assertFalse(ba.enthaelt(65)); + assertTrue(ba.enthaelt(805)); + assertTrue(ba.enthaelt(224)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(604)); + assertTrue(ba.enthaelt(273)); + assertTrue(ba.enthaelt(161)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(590)); + } + + @Test + public void test011() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(10)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(895)); + assertTrue(ba.enthaelt(344)); + assertFalse(ba.enthaelt(966)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(181)); + assertFalse(ba.enthaelt(661)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(54)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(690)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(185)); + assertFalse(ba.enthaelt(657)); + assertTrue(ba.enthaelt(934)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(907)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(348)); + } + + @Test + public void test012() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(11)); + assertEquals(313,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(42)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(650)); + assertTrue(ba.enthaelt(61)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(1013)); + assertFalse(ba.enthaelt(368)); + assertFalse(ba.enthaelt(703)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(559)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(987)); + assertTrue(ba.enthaelt(582)); + assertTrue(ba.enthaelt(845)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(656)); + } + + @Test + public void test013() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(12)); + assertEquals(171,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(146)); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(114)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(51)); + assertFalse(ba.enthaelt(399)); + assertFalse(ba.enthaelt(43)); + assertTrue(ba.enthaelt(595)); + assertTrue(ba.enthaelt(831)); + assertFalse(ba.enthaelt(259)); + assertTrue(ba.enthaelt(960)); + assertTrue(ba.enthaelt(919)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(394)); + assertTrue(ba.enthaelt(466)); + assertTrue(ba.enthaelt(459)); + assertTrue(ba.enthaelt(539)); + } + + @Test + public void test014() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(13)); + assertEquals(135,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(870)); + assertFalse(ba.enthaelt(978)); + assertFalse(ba.enthaelt(871)); + assertFalse(ba.enthaelt(669)); + assertFalse(ba.enthaelt(793)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(480)); + assertTrue(ba.enthaelt(449)); + assertFalse(ba.enthaelt(380)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(436)); + assertTrue(ba.enthaelt(120)); + assertTrue(ba.enthaelt(433)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(993)); + } + + @Test + public void test015() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(14)); + assertEquals(101,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(583)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(157)); + assertFalse(ba.enthaelt(170)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(458)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(727)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(155)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test016() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(15)); + assertEquals(105,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(796)); + assertFalse(ba.enthaelt(842)); + assertFalse(ba.enthaelt(853)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(795)); + assertFalse(ba.enthaelt(736)); + assertFalse(ba.enthaelt(76)); + assertFalse(ba.enthaelt(325)); + assertFalse(ba.enthaelt(258)); + assertFalse(ba.enthaelt(483)); + assertTrue(ba.enthaelt(190)); + assertTrue(ba.enthaelt(590)); + assertTrue(ba.enthaelt(16)); + assertTrue(ba.enthaelt(534)); + assertTrue(ba.enthaelt(762)); + assertTrue(ba.enthaelt(567)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(775)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(760)); + } + + @Test + public void test017() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(16)); + assertEquals(95,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(745)); + assertTrue(ba.enthaelt(293)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(180)); + assertFalse(ba.enthaelt(188)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(356)); + assertFalse(ba.enthaelt(973)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(54)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(520)); + assertTrue(ba.enthaelt(429)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(194)); + } + + @Test + public void test018() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(17)); + assertEquals(315,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(837)); + assertTrue(ba.enthaelt(543)); + assertFalse(ba.enthaelt(696)); + assertFalse(ba.enthaelt(307)); + assertTrue(ba.enthaelt(140)); + assertFalse(ba.enthaelt(835)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(498)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(405)); + assertFalse(ba.enthaelt(178)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(418)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(997)); + assertTrue(ba.enthaelt(534)); + } + + @Test + public void test019() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(18)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(709)); + assertFalse(ba.enthaelt(22)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(892)); + assertFalse(ba.enthaelt(176)); + assertFalse(ba.enthaelt(680)); + assertFalse(ba.enthaelt(729)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(198)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(917)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(640)); + assertTrue(ba.enthaelt(98)); + assertTrue(ba.enthaelt(521)); + assertTrue(ba.enthaelt(586)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(197)); + } + + @Test + public void test020() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(19)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(471)); + assertFalse(ba.enthaelt(742)); + assertFalse(ba.enthaelt(362)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(682)); + assertFalse(ba.enthaelt(336)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(895)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(495)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(807)); + assertTrue(ba.enthaelt(853)); + } + + @Test + public void test021() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(20)); + assertEquals(279,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(439)); + assertTrue(ba.enthaelt(687)); + assertFalse(ba.enthaelt(216)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(516)); + assertTrue(ba.enthaelt(335)); + assertFalse(ba.enthaelt(703)); + assertTrue(ba.enthaelt(132)); + assertTrue(ba.enthaelt(630)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(606)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(422)); + assertFalse(ba.enthaelt(43)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(410)); + assertTrue(ba.enthaelt(235)); + assertTrue(ba.enthaelt(103)); + } + + @Test + public void test022() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(21)); + assertEquals(215,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(310)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(474)); + assertFalse(ba.enthaelt(123)); + assertTrue(ba.enthaelt(824)); + assertFalse(ba.enthaelt(756)); + assertFalse(ba.enthaelt(829)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(755)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(715)); + assertTrue(ba.enthaelt(662)); + assertTrue(ba.enthaelt(73)); + assertTrue(ba.enthaelt(195)); + assertTrue(ba.enthaelt(365)); + assertTrue(ba.enthaelt(889)); + } + + @Test + public void test023() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(22)); + assertEquals(107,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(821)); + assertFalse(ba.enthaelt(165)); + assertFalse(ba.enthaelt(884)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(545)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(435)); + assertFalse(ba.enthaelt(493)); + assertFalse(ba.enthaelt(823)); + assertFalse(ba.enthaelt(355)); + assertTrue(ba.enthaelt(276)); + assertTrue(ba.enthaelt(84)); + assertTrue(ba.enthaelt(265)); + assertTrue(ba.enthaelt(140)); + assertTrue(ba.enthaelt(529)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(879)); + assertTrue(ba.enthaelt(724)); + assertTrue(ba.enthaelt(352)); + } + + @Test + public void test024() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(23)); + assertEquals(207,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(268)); + assertFalse(ba.enthaelt(332)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(666)); + assertTrue(ba.enthaelt(36)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(537)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(944)); + assertFalse(ba.enthaelt(941)); + assertTrue(ba.enthaelt(665)); + assertTrue(ba.enthaelt(967)); + assertTrue(ba.enthaelt(667)); + assertTrue(ba.enthaelt(684)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(800)); + } + + @Test + public void test025() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(24)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(197)); + assertFalse(ba.enthaelt(983)); + assertFalse(ba.enthaelt(470)); + assertFalse(ba.enthaelt(487)); + assertTrue(ba.enthaelt(44)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(714)); + assertFalse(ba.enthaelt(623)); + assertTrue(ba.enthaelt(18)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(864)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(488)); + } + + @Test + public void test026() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(25)); + assertEquals(247,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(999)); + assertTrue(ba.enthaelt(173)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(892)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(919)); + assertFalse(ba.enthaelt(70)); + assertFalse(ba.enthaelt(4)); + assertFalse(ba.enthaelt(462)); + assertFalse(ba.enthaelt(877)); + assertFalse(ba.enthaelt(568)); + assertTrue(ba.enthaelt(834)); + assertTrue(ba.enthaelt(382)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(575)); + assertTrue(ba.enthaelt(19)); + assertTrue(ba.enthaelt(528)); + } + + @Test + public void test027() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(26)); + assertEquals(179,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(626)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(365)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(366)); + assertFalse(ba.enthaelt(814)); + assertFalse(ba.enthaelt(900)); + assertTrue(ba.enthaelt(496)); + assertFalse(ba.enthaelt(133)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(391)); + assertFalse(ba.enthaelt(801)); + assertFalse(ba.enthaelt(420)); + assertTrue(ba.enthaelt(310)); + assertTrue(ba.enthaelt(277)); + assertTrue(ba.enthaelt(262)); + assertTrue(ba.enthaelt(513)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(403)); + } + + @Test + public void test028() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(27)); + assertEquals(209,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(627)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(393)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(364)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(173)); + assertFalse(ba.enthaelt(257)); + assertFalse(ba.enthaelt(277)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(896)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(706)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(480)); + assertTrue(ba.enthaelt(926)); + assertTrue(ba.enthaelt(832)); + assertTrue(ba.enthaelt(271)); + } + + @Test + public void test029() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(28)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(942)); + assertTrue(ba.enthaelt(924)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(528)); + assertFalse(ba.enthaelt(495)); + assertFalse(ba.enthaelt(262)); + assertFalse(ba.enthaelt(413)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(230)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(758)); + assertTrue(ba.enthaelt(91)); + assertTrue(ba.enthaelt(995)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(62)); + } + + @Test + public void test030() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(29)); + assertEquals(71,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(846)); + assertFalse(ba.enthaelt(828)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(456)); + assertFalse(ba.enthaelt(424)); + assertFalse(ba.enthaelt(454)); + assertFalse(ba.enthaelt(908)); + assertFalse(ba.enthaelt(200)); + assertFalse(ba.enthaelt(463)); + assertFalse(ba.enthaelt(246)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(553)); + assertTrue(ba.enthaelt(223)); + assertTrue(ba.enthaelt(237)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(222)); + assertTrue(ba.enthaelt(806)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(10)); + } + + @Test + public void test031() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(30)); + assertEquals(109,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(154)); + assertFalse(ba.enthaelt(1000)); + assertTrue(ba.enthaelt(355)); + assertFalse(ba.enthaelt(960)); + assertFalse(ba.enthaelt(301)); + assertFalse(ba.enthaelt(94)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(440)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(71)); + assertFalse(ba.enthaelt(44)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(752)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(122)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(923)); + assertTrue(ba.enthaelt(689)); + } + + @Test + public void test032() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(31)); + assertEquals(87,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(866)); + assertTrue(ba.enthaelt(304)); + assertFalse(ba.enthaelt(623)); + assertFalse(ba.enthaelt(261)); + assertFalse(ba.enthaelt(761)); + assertTrue(ba.enthaelt(206)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(769)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(37)); + assertFalse(ba.enthaelt(622)); + assertTrue(ba.enthaelt(61)); + assertTrue(ba.enthaelt(409)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(30)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(868)); + assertTrue(ba.enthaelt(36)); + } + + @Test + public void test033() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(32)); + assertEquals(521,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(211)); + assertFalse(ba.enthaelt(231)); + assertTrue(ba.enthaelt(658)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(53)); + assertTrue(ba.enthaelt(764)); + assertTrue(ba.enthaelt(324)); + assertTrue(ba.enthaelt(851)); + assertFalse(ba.enthaelt(856)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(15)); + assertFalse(ba.enthaelt(223)); + assertTrue(ba.enthaelt(553)); + assertFalse(ba.enthaelt(782)); + assertFalse(ba.enthaelt(419)); + assertFalse(ba.enthaelt(90)); + assertFalse(ba.enthaelt(221)); + assertFalse(ba.enthaelt(670)); + assertTrue(ba.enthaelt(876)); + assertFalse(ba.enthaelt(902)); + } + + @Test + public void test034() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(33)); + assertEquals(59,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(617)); + assertFalse(ba.enthaelt(253)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(190)); + assertFalse(ba.enthaelt(779)); + assertFalse(ba.enthaelt(994)); + assertFalse(ba.enthaelt(941)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(351)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(205)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(230)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(705)); + } + + @Test + public void test035() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(34)); + assertEquals(107,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(238)); + assertFalse(ba.enthaelt(35)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(134)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(137)); + assertTrue(ba.enthaelt(243)); + assertFalse(ba.enthaelt(780)); + assertFalse(ba.enthaelt(422)); + assertFalse(ba.enthaelt(930)); + assertTrue(ba.enthaelt(437)); + assertTrue(ba.enthaelt(251)); + assertTrue(ba.enthaelt(802)); + assertTrue(ba.enthaelt(206)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(79)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(384)); + assertTrue(ba.enthaelt(665)); + } + + @Test + public void test036() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(35)); + assertEquals(93,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(413)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(427)); + assertFalse(ba.enthaelt(660)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(30)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(191)); + assertTrue(ba.enthaelt(93)); + assertTrue(ba.enthaelt(326)); + assertTrue(ba.enthaelt(700)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(546)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test037() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(36)); + assertEquals(175,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(833)); + assertFalse(ba.enthaelt(408)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(559)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(281)); + assertTrue(ba.enthaelt(477)); + assertTrue(ba.enthaelt(920)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(726)); + assertFalse(ba.enthaelt(659)); + assertFalse(ba.enthaelt(786)); + assertFalse(ba.enthaelt(876)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(901)); + assertTrue(ba.enthaelt(260)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(782)); + } + + @Test + public void test038() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(37)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(947)); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(185)); + assertTrue(ba.enthaelt(255)); + assertFalse(ba.enthaelt(684)); + assertTrue(ba.enthaelt(393)); + assertTrue(ba.enthaelt(88)); + assertFalse(ba.enthaelt(633)); + assertFalse(ba.enthaelt(220)); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(686)); + assertFalse(ba.enthaelt(579)); + assertTrue(ba.enthaelt(501)); + assertTrue(ba.enthaelt(616)); + assertTrue(ba.enthaelt(389)); + assertTrue(ba.enthaelt(285)); + assertTrue(ba.enthaelt(704)); + assertTrue(ba.enthaelt(253)); + } + + @Test + public void test039() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(38)); + assertEquals(129,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(572)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(116)); + assertFalse(ba.enthaelt(524)); + assertFalse(ba.enthaelt(569)); + assertFalse(ba.enthaelt(1)); + assertFalse(ba.enthaelt(794)); + assertFalse(ba.enthaelt(300)); + assertFalse(ba.enthaelt(865)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(408)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(154)); + assertTrue(ba.enthaelt(734)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(284)); + assertTrue(ba.enthaelt(628)); + } + + @Test + public void test040() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(39)); + assertEquals(281,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(19)); + assertFalse(ba.enthaelt(848)); + assertFalse(ba.enthaelt(681)); + assertFalse(ba.enthaelt(878)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(38)); + assertFalse(ba.enthaelt(641)); + assertTrue(ba.enthaelt(634)); + assertFalse(ba.enthaelt(577)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(300)); + assertTrue(ba.enthaelt(760)); + assertTrue(ba.enthaelt(476)); + assertTrue(ba.enthaelt(899)); + assertTrue(ba.enthaelt(851)); + assertTrue(ba.enthaelt(618)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(244)); + assertTrue(ba.enthaelt(401)); + } + + @Test + public void test041() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(40)); + assertEquals(117,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(517)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(382)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(949)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(733)); + assertTrue(ba.enthaelt(847)); + assertFalse(ba.enthaelt(741)); + assertFalse(ba.enthaelt(868)); + assertFalse(ba.enthaelt(785)); + assertTrue(ba.enthaelt(544)); + assertTrue(ba.enthaelt(302)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(449)); + assertTrue(ba.enthaelt(620)); + assertTrue(ba.enthaelt(465)); + assertTrue(ba.enthaelt(587)); + } + + @Test + public void test042() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(41)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(201)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(287)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(225)); + assertFalse(ba.enthaelt(224)); + assertTrue(ba.enthaelt(994)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(1006)); + assertFalse(ba.enthaelt(488)); + assertFalse(ba.enthaelt(746)); + assertTrue(ba.enthaelt(179)); + assertTrue(ba.enthaelt(1)); + assertTrue(ba.enthaelt(903)); + assertTrue(ba.enthaelt(522)); + assertTrue(ba.enthaelt(407)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(156)); + } + + @Test + public void test043() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(42)); + assertEquals(157,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(608)); + assertTrue(ba.enthaelt(375)); + assertFalse(ba.enthaelt(689)); + assertFalse(ba.enthaelt(856)); + assertTrue(ba.enthaelt(139)); + assertFalse(ba.enthaelt(693)); + assertFalse(ba.enthaelt(887)); + assertFalse(ba.enthaelt(481)); + assertFalse(ba.enthaelt(256)); + assertFalse(ba.enthaelt(182)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(114)); + assertTrue(ba.enthaelt(875)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(744)); + assertTrue(ba.enthaelt(78)); + assertTrue(ba.enthaelt(797)); + assertTrue(ba.enthaelt(362)); + assertTrue(ba.enthaelt(755)); + } + + @Test + public void test044() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(43)); + assertEquals(347,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(357)); + assertFalse(ba.enthaelt(718)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(58)); + assertFalse(ba.enthaelt(313)); + assertFalse(ba.enthaelt(530)); + assertTrue(ba.enthaelt(902)); + assertFalse(ba.enthaelt(402)); + assertTrue(ba.enthaelt(197)); + assertFalse(ba.enthaelt(854)); + assertTrue(ba.enthaelt(751)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(220)); + assertFalse(ba.enthaelt(835)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(859)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(237)); + } + + @Test + public void test045() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(44)); + assertEquals(459,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(126)); + assertFalse(ba.enthaelt(328)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(597)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(747)); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(93)); + assertFalse(ba.enthaelt(866)); + assertTrue(ba.enthaelt(271)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(228)); + assertTrue(ba.enthaelt(241)); + assertTrue(ba.enthaelt(335)); + assertTrue(ba.enthaelt(257)); + assertTrue(ba.enthaelt(83)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(498)); + assertTrue(ba.enthaelt(366)); + } + + @Test + public void test046() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(45)); + assertEquals(187,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(916)); + assertFalse(ba.enthaelt(489)); + assertFalse(ba.enthaelt(370)); + assertFalse(ba.enthaelt(361)); + assertFalse(ba.enthaelt(635)); + assertFalse(ba.enthaelt(991)); + assertTrue(ba.enthaelt(308)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(203)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(992)); + assertTrue(ba.enthaelt(72)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(357)); + assertTrue(ba.enthaelt(535)); + assertTrue(ba.enthaelt(623)); + assertTrue(ba.enthaelt(526)); + assertTrue(ba.enthaelt(483)); + } + + @Test + public void test047() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(46)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(174)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(679)); + assertFalse(ba.enthaelt(459)); + assertFalse(ba.enthaelt(522)); + assertFalse(ba.enthaelt(552)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(578)); + assertTrue(ba.enthaelt(157)); + assertTrue(ba.enthaelt(830)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(307)); + assertTrue(ba.enthaelt(516)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(378)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(23)); + } + + @Test + public void test048() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(47)); + assertEquals(81,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(763)); + assertFalse(ba.enthaelt(697)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(516)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(874)); + assertFalse(ba.enthaelt(331)); + assertFalse(ba.enthaelt(602)); + assertFalse(ba.enthaelt(952)); + assertFalse(ba.enthaelt(928)); + assertTrue(ba.enthaelt(794)); + assertTrue(ba.enthaelt(342)); + assertTrue(ba.enthaelt(551)); + assertTrue(ba.enthaelt(600)); + assertTrue(ba.enthaelt(532)); + assertTrue(ba.enthaelt(86)); + assertTrue(ba.enthaelt(217)); + assertTrue(ba.enthaelt(921)); + assertTrue(ba.enthaelt(115)); + assertTrue(ba.enthaelt(32)); + } + + @Test + public void test049() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(48)); + assertEquals(349,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(394)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(3)); + assertTrue(ba.enthaelt(400)); + assertFalse(ba.enthaelt(264)); + assertFalse(ba.enthaelt(823)); + assertTrue(ba.enthaelt(569)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(1008)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(818)); + assertFalse(ba.enthaelt(902)); + assertTrue(ba.enthaelt(41)); + assertFalse(ba.enthaelt(631)); + assertFalse(ba.enthaelt(927)); + assertTrue(ba.enthaelt(790)); + assertTrue(ba.enthaelt(464)); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(203)); + assertTrue(ba.enthaelt(774)); + } + + @Test + public void test050() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(49)); + assertEquals(73,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertTrue(ba.enthaelt(942)); + assertFalse(ba.enthaelt(310)); + assertFalse(ba.enthaelt(44)); + assertFalse(ba.enthaelt(536)); + assertFalse(ba.enthaelt(512)); + assertTrue(ba.enthaelt(257)); + assertFalse(ba.enthaelt(219)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(474)); + assertTrue(ba.enthaelt(21)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(358)); + assertFalse(ba.enthaelt(651)); + assertTrue(ba.enthaelt(97)); + assertTrue(ba.enthaelt(309)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(502)); + } + + @Test + public void test051() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(50)); + assertEquals(115,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(199)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(721)); + assertFalse(ba.enthaelt(396)); + assertFalse(ba.enthaelt(318)); + assertFalse(ba.enthaelt(625)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(324)); + assertFalse(ba.enthaelt(913)); + assertTrue(ba.enthaelt(869)); + assertTrue(ba.enthaelt(541)); + assertTrue(ba.enthaelt(444)); + assertTrue(ba.enthaelt(937)); + assertTrue(ba.enthaelt(837)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(843)); + assertTrue(ba.enthaelt(236)); + assertTrue(ba.enthaelt(954)); + assertTrue(ba.enthaelt(752)); + } + + @Test + public void test052() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(51)); + assertEquals(437,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(352)); + assertTrue(ba.enthaelt(305)); + assertFalse(ba.enthaelt(708)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(281)); + assertFalse(ba.enthaelt(677)); + assertTrue(ba.enthaelt(410)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(555)); + assertFalse(ba.enthaelt(1004)); + assertFalse(ba.enthaelt(768)); + assertFalse(ba.enthaelt(774)); + assertTrue(ba.enthaelt(491)); + assertTrue(ba.enthaelt(589)); + assertFalse(ba.enthaelt(360)); + assertFalse(ba.enthaelt(720)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(871)); + assertTrue(ba.enthaelt(538)); + assertTrue(ba.enthaelt(918)); + } + + @Test + public void test053() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(52)); + assertEquals(209,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(719)); + assertFalse(ba.enthaelt(933)); + assertFalse(ba.enthaelt(77)); + assertFalse(ba.enthaelt(844)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(1008)); + assertFalse(ba.enthaelt(208)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(171)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(44)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(343)); + assertTrue(ba.enthaelt(177)); + assertTrue(ba.enthaelt(488)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(574)); + assertTrue(ba.enthaelt(765)); + assertTrue(ba.enthaelt(150)); + } + + @Test + public void test054() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(53)); + assertEquals(151,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(254)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(119)); + assertFalse(ba.enthaelt(605)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(738)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(27)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(1003)); + assertFalse(ba.enthaelt(971)); + assertFalse(ba.enthaelt(283)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(159)); + assertTrue(ba.enthaelt(505)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(126)); + } + + @Test + public void test055() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(54)); + assertEquals(311,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(619)); + assertTrue(ba.enthaelt(583)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(436)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(587)); + assertTrue(ba.enthaelt(880)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(225)); + assertFalse(ba.enthaelt(460)); + assertFalse(ba.enthaelt(501)); + assertFalse(ba.enthaelt(286)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(589)); + assertFalse(ba.enthaelt(773)); + assertTrue(ba.enthaelt(912)); + assertTrue(ba.enthaelt(671)); + assertTrue(ba.enthaelt(245)); + assertTrue(ba.enthaelt(145)); + } + + @Test + public void test056() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(55)); + assertEquals(93,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(232)); + assertFalse(ba.enthaelt(504)); + assertFalse(ba.enthaelt(951)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(292)); + assertFalse(ba.enthaelt(575)); + assertFalse(ba.enthaelt(188)); + assertFalse(ba.enthaelt(255)); + assertFalse(ba.enthaelt(913)); + assertFalse(ba.enthaelt(592)); + assertFalse(ba.enthaelt(649)); + assertTrue(ba.enthaelt(897)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(128)); + assertTrue(ba.enthaelt(228)); + assertTrue(ba.enthaelt(430)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(497)); + assertTrue(ba.enthaelt(317)); + assertTrue(ba.enthaelt(269)); + } + + @Test + public void test057() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(56)); + assertEquals(499,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(557)); + assertFalse(ba.enthaelt(863)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(116)); + assertFalse(ba.enthaelt(841)); + assertTrue(ba.enthaelt(683)); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(783)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(87)); + assertTrue(ba.enthaelt(983)); + assertTrue(ba.enthaelt(810)); + assertTrue(ba.enthaelt(354)); + assertFalse(ba.enthaelt(155)); + assertFalse(ba.enthaelt(2)); + assertFalse(ba.enthaelt(725)); + assertTrue(ba.enthaelt(786)); + assertTrue(ba.enthaelt(916)); + assertFalse(ba.enthaelt(1009)); + } + + @Test + public void test058() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(57)); + assertEquals(243,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(737)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(1004)); + assertTrue(ba.enthaelt(633)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(743)); + assertFalse(ba.enthaelt(998)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(365)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(517)); + assertTrue(ba.enthaelt(242)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(404)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(337)); + assertTrue(ba.enthaelt(347)); + assertTrue(ba.enthaelt(133)); + } + + @Test + public void test059() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(58)); + assertEquals(875,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(665)); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(855)); + assertFalse(ba.enthaelt(490)); + assertFalse(ba.enthaelt(690)); + assertFalse(ba.enthaelt(975)); + assertTrue(ba.enthaelt(385)); + assertTrue(ba.enthaelt(789)); + assertFalse(ba.enthaelt(625)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(818)); + assertFalse(ba.enthaelt(442)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(566)); + assertFalse(ba.enthaelt(1001)); + assertFalse(ba.enthaelt(886)); + assertTrue(ba.enthaelt(49)); + assertFalse(ba.enthaelt(463)); + assertTrue(ba.enthaelt(29)); + assertTrue(ba.enthaelt(84)); + } + + @Test + public void test060() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(59)); + assertEquals(251,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertTrue(ba.enthaelt(81)); + assertFalse(ba.enthaelt(447)); + assertTrue(ba.enthaelt(998)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(1000)); + assertFalse(ba.enthaelt(118)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(570)); + assertFalse(ba.enthaelt(104)); + assertTrue(ba.enthaelt(495)); + assertFalse(ba.enthaelt(584)); + assertFalse(ba.enthaelt(560)); + assertTrue(ba.enthaelt(623)); + assertFalse(ba.enthaelt(1005)); + assertTrue(ba.enthaelt(740)); + assertTrue(ba.enthaelt(360)); + assertTrue(ba.enthaelt(630)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(220)); + assertTrue(ba.enthaelt(469)); + } + + @Test + public void test061() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(60)); + assertEquals(97,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(432)); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(752)); + assertFalse(ba.enthaelt(751)); + assertFalse(ba.enthaelt(998)); + assertTrue(ba.enthaelt(9)); + assertFalse(ba.enthaelt(940)); + assertFalse(ba.enthaelt(1002)); + assertFalse(ba.enthaelt(296)); + assertFalse(ba.enthaelt(951)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(392)); + assertTrue(ba.enthaelt(226)); + assertTrue(ba.enthaelt(885)); + assertTrue(ba.enthaelt(350)); + assertTrue(ba.enthaelt(799)); + assertTrue(ba.enthaelt(877)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(836)); + } + + @Test + public void test062() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(61)); + assertEquals(85,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(1019)); + assertFalse(ba.enthaelt(997)); + assertFalse(ba.enthaelt(340)); + assertFalse(ba.enthaelt(594)); + assertFalse(ba.enthaelt(996)); + assertFalse(ba.enthaelt(766)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(192)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(869)); + assertTrue(ba.enthaelt(75)); + assertTrue(ba.enthaelt(3)); + assertTrue(ba.enthaelt(634)); + assertTrue(ba.enthaelt(814)); + assertTrue(ba.enthaelt(438)); + assertTrue(ba.enthaelt(785)); + assertTrue(ba.enthaelt(755)); + assertTrue(ba.enthaelt(446)); + assertTrue(ba.enthaelt(414)); + assertTrue(ba.enthaelt(579)); + } + + @Test + public void test063() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(62)); + assertEquals(221,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(251)); + assertFalse(ba.enthaelt(138)); + assertTrue(ba.enthaelt(803)); + assertFalse(ba.enthaelt(280)); + assertFalse(ba.enthaelt(62)); + assertFalse(ba.enthaelt(665)); + assertFalse(ba.enthaelt(429)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(656)); + assertTrue(ba.enthaelt(463)); + assertFalse(ba.enthaelt(131)); + assertFalse(ba.enthaelt(759)); + assertFalse(ba.enthaelt(26)); + assertTrue(ba.enthaelt(303)); + assertTrue(ba.enthaelt(213)); + assertTrue(ba.enthaelt(167)); + assertTrue(ba.enthaelt(399)); + assertTrue(ba.enthaelt(264)); + assertTrue(ba.enthaelt(944)); + assertTrue(ba.enthaelt(625)); + } + + @Test + public void test064() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(63)); + assertEquals(115,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(690)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(525)); + assertFalse(ba.enthaelt(448)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(628)); + assertFalse(ba.enthaelt(444)); + assertFalse(ba.enthaelt(28)); + assertFalse(ba.enthaelt(622)); + assertFalse(ba.enthaelt(270)); + assertFalse(ba.enthaelt(731)); + assertTrue(ba.enthaelt(38)); + assertTrue(ba.enthaelt(479)); + assertTrue(ba.enthaelt(182)); + assertTrue(ba.enthaelt(24)); + assertTrue(ba.enthaelt(754)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(838)); + assertTrue(ba.enthaelt(85)); + assertTrue(ba.enthaelt(289)); + } + + @Test + public void test065() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(64)); + assertEquals(513,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(579)); + assertFalse(ba.enthaelt(140)); + assertFalse(ba.enthaelt(598)); + assertFalse(ba.enthaelt(303)); + assertTrue(ba.enthaelt(524)); + assertFalse(ba.enthaelt(776)); + assertFalse(ba.enthaelt(522)); + assertTrue(ba.enthaelt(323)); + assertFalse(ba.enthaelt(168)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(922)); + assertFalse(ba.enthaelt(3)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(900)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(113)); + assertTrue(ba.enthaelt(274)); + assertTrue(ba.enthaelt(653)); + assertTrue(ba.enthaelt(958)); + assertTrue(ba.enthaelt(866)); + } + + @Test + public void test066() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(65)); + assertEquals(79,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(658)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(441)); + assertTrue(ba.enthaelt(976)); + assertFalse(ba.enthaelt(797)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(159)); + assertFalse(ba.enthaelt(305)); + assertFalse(ba.enthaelt(486)); + assertFalse(ba.enthaelt(290)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(216)); + assertTrue(ba.enthaelt(696)); + assertTrue(ba.enthaelt(517)); + assertTrue(ba.enthaelt(898)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(243)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(225)); + } + + @Test + public void test067() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(66)); + assertEquals(145,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(588)); + assertFalse(ba.enthaelt(860)); + assertTrue(ba.enthaelt(451)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(634)); + assertFalse(ba.enthaelt(154)); + assertTrue(ba.enthaelt(146)); + assertFalse(ba.enthaelt(581)); + assertFalse(ba.enthaelt(778)); + assertFalse(ba.enthaelt(986)); + assertFalse(ba.enthaelt(580)); + assertFalse(ba.enthaelt(685)); + assertTrue(ba.enthaelt(305)); + assertTrue(ba.enthaelt(669)); + assertTrue(ba.enthaelt(106)); + assertTrue(ba.enthaelt(635)); + assertTrue(ba.enthaelt(173)); + assertTrue(ba.enthaelt(536)); + assertTrue(ba.enthaelt(249)); + assertTrue(ba.enthaelt(244)); + } + + @Test + public void test068() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(67)); + assertEquals(653,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertTrue(ba.enthaelt(950)); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(499)); + assertFalse(ba.enthaelt(543)); + assertTrue(ba.enthaelt(161)); + assertFalse(ba.enthaelt(288)); + assertFalse(ba.enthaelt(135)); + assertTrue(ba.enthaelt(119)); + assertTrue(ba.enthaelt(379)); + assertFalse(ba.enthaelt(9)); + assertFalse(ba.enthaelt(854)); + assertFalse(ba.enthaelt(634)); + assertTrue(ba.enthaelt(215)); + assertFalse(ba.enthaelt(345)); + assertTrue(ba.enthaelt(326)); + assertFalse(ba.enthaelt(948)); + assertTrue(ba.enthaelt(328)); + assertTrue(ba.enthaelt(803)); + assertTrue(ba.enthaelt(463)); + assertTrue(ba.enthaelt(212)); + } + + @Test + public void test069() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(68)); + assertEquals(231,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(450)); + assertFalse(ba.enthaelt(942)); + assertFalse(ba.enthaelt(343)); + assertFalse(ba.enthaelt(195)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(377)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(727)); + assertFalse(ba.enthaelt(643)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(569)); + assertTrue(ba.enthaelt(852)); + assertTrue(ba.enthaelt(808)); + assertTrue(ba.enthaelt(771)); + assertTrue(ba.enthaelt(874)); + assertTrue(ba.enthaelt(49)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(176)); + assertTrue(ba.enthaelt(198)); + } + + @Test + public void test070() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(69)); + assertEquals(241,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(982)); + assertFalse(ba.enthaelt(326)); + assertTrue(ba.enthaelt(925)); + assertTrue(ba.enthaelt(680)); + assertTrue(ba.enthaelt(71)); + assertFalse(ba.enthaelt(494)); + assertFalse(ba.enthaelt(841)); + assertFalse(ba.enthaelt(915)); + assertTrue(ba.enthaelt(100)); + assertFalse(ba.enthaelt(215)); + assertFalse(ba.enthaelt(48)); + assertFalse(ba.enthaelt(5)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(372)); + assertTrue(ba.enthaelt(908)); + assertTrue(ba.enthaelt(451)); + assertTrue(ba.enthaelt(258)); + assertTrue(ba.enthaelt(473)); + assertTrue(ba.enthaelt(861)); + assertTrue(ba.enthaelt(734)); + } + + @Test + public void test071() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(70)); + assertEquals(147,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(803)); + assertFalse(ba.enthaelt(898)); + assertFalse(ba.enthaelt(464)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(439)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(750)); + assertTrue(ba.enthaelt(494)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(119)); + assertFalse(ba.enthaelt(113)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(617)); + assertTrue(ba.enthaelt(644)); + assertTrue(ba.enthaelt(537)); + assertTrue(ba.enthaelt(471)); + assertTrue(ba.enthaelt(70)); + assertTrue(ba.enthaelt(769)); + assertTrue(ba.enthaelt(581)); + } + + @Test + public void test072() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(71)); + assertEquals(165,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(447)); + assertTrue(ba.enthaelt(675)); + assertFalse(ba.enthaelt(172)); + assertFalse(ba.enthaelt(438)); + assertTrue(ba.enthaelt(105)); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(328)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(293)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(466)); + assertFalse(ba.enthaelt(572)); + assertTrue(ba.enthaelt(499)); + assertFalse(ba.enthaelt(218)); + assertTrue(ba.enthaelt(518)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(32)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(152)); + assertTrue(ba.enthaelt(19)); + } + + @Test + public void test073() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(72)); + assertEquals(231,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(908)); + assertTrue(ba.enthaelt(138)); + assertFalse(ba.enthaelt(1012)); + assertFalse(ba.enthaelt(189)); + assertTrue(ba.enthaelt(745)); + assertFalse(ba.enthaelt(799)); + assertTrue(ba.enthaelt(922)); + assertTrue(ba.enthaelt(595)); + assertFalse(ba.enthaelt(391)); + assertFalse(ba.enthaelt(31)); + assertFalse(ba.enthaelt(177)); + assertFalse(ba.enthaelt(673)); + assertFalse(ba.enthaelt(348)); + assertTrue(ba.enthaelt(850)); + assertTrue(ba.enthaelt(162)); + assertTrue(ba.enthaelt(820)); + assertTrue(ba.enthaelt(219)); + assertTrue(ba.enthaelt(388)); + assertTrue(ba.enthaelt(694)); + } + + @Test + public void test074() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(73)); + assertEquals(191,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(92)); + assertFalse(ba.enthaelt(929)); + assertTrue(ba.enthaelt(312)); + assertFalse(ba.enthaelt(209)); + assertFalse(ba.enthaelt(843)); + assertFalse(ba.enthaelt(935)); + assertFalse(ba.enthaelt(6)); + assertFalse(ba.enthaelt(529)); + assertFalse(ba.enthaelt(567)); + assertFalse(ba.enthaelt(646)); + assertFalse(ba.enthaelt(116)); + assertTrue(ba.enthaelt(788)); + assertTrue(ba.enthaelt(487)); + assertTrue(ba.enthaelt(330)); + assertTrue(ba.enthaelt(813)); + assertTrue(ba.enthaelt(77)); + assertTrue(ba.enthaelt(624)); + assertTrue(ba.enthaelt(722)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(215)); + } + + @Test + public void test075() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(74)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(733)); + assertTrue(ba.enthaelt(561)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(820)); + assertFalse(ba.enthaelt(230)); + assertFalse(ba.enthaelt(40)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(624)); + assertFalse(ba.enthaelt(872)); + assertFalse(ba.enthaelt(375)); + assertFalse(ba.enthaelt(394)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(815)); + assertTrue(ba.enthaelt(951)); + assertTrue(ba.enthaelt(821)); + assertTrue(ba.enthaelt(364)); + assertTrue(ba.enthaelt(293)); + assertTrue(ba.enthaelt(58)); + assertTrue(ba.enthaelt(798)); + assertTrue(ba.enthaelt(51)); + } + + @Test + public void test076() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(75)); + assertEquals(63,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(272)); + assertTrue(ba.enthaelt(251)); + assertFalse(ba.enthaelt(961)); + assertFalse(ba.enthaelt(214)); + assertFalse(ba.enthaelt(963)); + assertFalse(ba.enthaelt(921)); + assertTrue(ba.enthaelt(278)); + assertFalse(ba.enthaelt(521)); + assertFalse(ba.enthaelt(302)); + assertFalse(ba.enthaelt(621)); + assertFalse(ba.enthaelt(640)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(829)); + assertTrue(ba.enthaelt(557)); + assertTrue(ba.enthaelt(419)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(581)); + assertTrue(ba.enthaelt(627)); + assertTrue(ba.enthaelt(385)); + } + + @Test + public void test077() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(76)); + assertEquals(265,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(59)); + assertTrue(ba.enthaelt(384)); + assertFalse(ba.enthaelt(286)); + assertTrue(ba.enthaelt(195)); + assertFalse(ba.enthaelt(432)); + assertTrue(ba.enthaelt(591)); + assertFalse(ba.enthaelt(107)); + assertTrue(ba.enthaelt(867)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(883)); + assertFalse(ba.enthaelt(206)); + assertFalse(ba.enthaelt(981)); + assertFalse(ba.enthaelt(32)); + assertFalse(ba.enthaelt(782)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(804)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(129)); + assertTrue(ba.enthaelt(483)); + assertTrue(ba.enthaelt(372)); + } + + @Test + public void test078() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(77)); + assertEquals(211,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(520)); + assertFalse(ba.enthaelt(832)); + assertTrue(ba.enthaelt(98)); + assertFalse(ba.enthaelt(240)); + assertFalse(ba.enthaelt(1015)); + assertFalse(ba.enthaelt(367)); + assertFalse(ba.enthaelt(237)); + assertFalse(ba.enthaelt(873)); + assertFalse(ba.enthaelt(672)); + assertFalse(ba.enthaelt(269)); + assertTrue(ba.enthaelt(115)); + assertFalse(ba.enthaelt(493)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(36)); + assertTrue(ba.enthaelt(766)); + assertTrue(ba.enthaelt(329)); + assertTrue(ba.enthaelt(519)); + assertTrue(ba.enthaelt(566)); + assertTrue(ba.enthaelt(192)); + assertTrue(ba.enthaelt(114)); + } + + @Test + public void test079() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(78)); + assertEquals(77,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(774)); + assertFalse(ba.enthaelt(217)); + assertFalse(ba.enthaelt(274)); + assertFalse(ba.enthaelt(342)); + assertFalse(ba.enthaelt(175)); + assertTrue(ba.enthaelt(282)); + assertFalse(ba.enthaelt(191)); + assertFalse(ba.enthaelt(640)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(17)); + assertFalse(ba.enthaelt(950)); + assertTrue(ba.enthaelt(14)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(127)); + assertTrue(ba.enthaelt(402)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(420)); + assertTrue(ba.enthaelt(151)); + assertTrue(ba.enthaelt(313)); + assertTrue(ba.enthaelt(747)); + } + + @Test + public void test080() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(79)); + assertEquals(301,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(21)); + assertFalse(ba.enthaelt(562)); + assertFalse(ba.enthaelt(89)); + assertTrue(ba.enthaelt(366)); + assertFalse(ba.enthaelt(207)); + assertFalse(ba.enthaelt(825)); + assertFalse(ba.enthaelt(289)); + assertFalse(ba.enthaelt(1016)); + assertFalse(ba.enthaelt(213)); + assertFalse(ba.enthaelt(326)); + assertFalse(ba.enthaelt(407)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(180)); + assertTrue(ba.enthaelt(504)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(239)); + assertTrue(ba.enthaelt(139)); + assertTrue(ba.enthaelt(327)); + assertTrue(ba.enthaelt(286)); + } + + @Test + public void test081() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(80)); + assertEquals(577,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(345)); + assertFalse(ba.enthaelt(461)); + assertFalse(ba.enthaelt(1007)); + assertTrue(ba.enthaelt(821)); + assertFalse(ba.enthaelt(446)); + assertTrue(ba.enthaelt(748)); + assertFalse(ba.enthaelt(400)); + assertTrue(ba.enthaelt(505)); + assertFalse(ba.enthaelt(898)); + assertTrue(ba.enthaelt(10)); + assertFalse(ba.enthaelt(72)); + assertTrue(ba.enthaelt(222)); + assertFalse(ba.enthaelt(977)); + assertTrue(ba.enthaelt(555)); + assertTrue(ba.enthaelt(870)); + assertFalse(ba.enthaelt(845)); + assertTrue(ba.enthaelt(795)); + assertTrue(ba.enthaelt(12)); + assertTrue(ba.enthaelt(233)); + assertFalse(ba.enthaelt(731)); + } + + @Test + public void test082() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(81)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(508)); + assertFalse(ba.enthaelt(542)); + assertFalse(ba.enthaelt(12)); + assertFalse(ba.enthaelt(739)); + assertFalse(ba.enthaelt(770)); + assertFalse(ba.enthaelt(1010)); + assertFalse(ba.enthaelt(1018)); + assertFalse(ba.enthaelt(15)); + assertTrue(ba.enthaelt(418)); + assertFalse(ba.enthaelt(969)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(191)); + assertTrue(ba.enthaelt(31)); + assertTrue(ba.enthaelt(299)); + assertTrue(ba.enthaelt(846)); + assertTrue(ba.enthaelt(768)); + assertTrue(ba.enthaelt(973)); + assertTrue(ba.enthaelt(772)); + assertTrue(ba.enthaelt(629)); + assertTrue(ba.enthaelt(844)); + } + + @Test + public void test083() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(82)); + assertEquals(393,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(762)); + assertFalse(ba.enthaelt(749)); + assertFalse(ba.enthaelt(560)); + assertFalse(ba.enthaelt(646)); + assertTrue(ba.enthaelt(558)); + assertFalse(ba.enthaelt(8)); + assertFalse(ba.enthaelt(683)); + assertFalse(ba.enthaelt(805)); + assertTrue(ba.enthaelt(668)); + assertTrue(ba.enthaelt(434)); + assertTrue(ba.enthaelt(483)); + assertFalse(ba.enthaelt(962)); + assertTrue(ba.enthaelt(137)); + assertTrue(ba.enthaelt(239)); + assertFalse(ba.enthaelt(747)); + assertTrue(ba.enthaelt(583)); + assertFalse(ba.enthaelt(298)); + assertTrue(ba.enthaelt(608)); + assertTrue(ba.enthaelt(914)); + assertTrue(ba.enthaelt(717)); + } + + @Test + public void test084() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(83)); + assertEquals(203,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(198)); + assertFalse(ba.enthaelt(805)); + assertFalse(ba.enthaelt(725)); + assertFalse(ba.enthaelt(434)); + assertTrue(ba.enthaelt(289)); + assertFalse(ba.enthaelt(330)); + assertTrue(ba.enthaelt(130)); + assertFalse(ba.enthaelt(876)); + assertFalse(ba.enthaelt(812)); + assertFalse(ba.enthaelt(989)); + assertFalse(ba.enthaelt(51)); + assertFalse(ba.enthaelt(594)); + assertTrue(ba.enthaelt(673)); + assertTrue(ba.enthaelt(988)); + assertTrue(ba.enthaelt(940)); + assertTrue(ba.enthaelt(352)); + assertTrue(ba.enthaelt(756)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(525)); + assertTrue(ba.enthaelt(196)); + } + + @Test + public void test085() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(84)); + assertEquals(123,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(332)); + assertTrue(ba.enthaelt(580)); + assertFalse(ba.enthaelt(197)); + assertTrue(ba.enthaelt(188)); + assertFalse(ba.enthaelt(175)); + assertFalse(ba.enthaelt(59)); + assertFalse(ba.enthaelt(402)); + assertFalse(ba.enthaelt(200)); + assertTrue(ba.enthaelt(265)); + assertFalse(ba.enthaelt(320)); + assertTrue(ba.enthaelt(969)); + assertFalse(ba.enthaelt(54)); + assertFalse(ba.enthaelt(190)); + assertTrue(ba.enthaelt(664)); + assertFalse(ba.enthaelt(1010)); + assertTrue(ba.enthaelt(340)); + assertTrue(ba.enthaelt(679)); + assertTrue(ba.enthaelt(909)); + assertTrue(ba.enthaelt(588)); + assertTrue(ba.enthaelt(416)); + } + + @Test + public void test086() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(85)); + assertEquals(425,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(406)); + assertFalse(ba.enthaelt(372)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(108)); + assertFalse(ba.enthaelt(158)); + assertFalse(ba.enthaelt(241)); + assertFalse(ba.enthaelt(24)); + assertFalse(ba.enthaelt(581)); + assertTrue(ba.enthaelt(258)); + assertFalse(ba.enthaelt(692)); + assertFalse(ba.enthaelt(127)); + assertTrue(ba.enthaelt(593)); + assertTrue(ba.enthaelt(212)); + assertTrue(ba.enthaelt(492)); + assertTrue(ba.enthaelt(767)); + assertTrue(ba.enthaelt(90)); + assertTrue(ba.enthaelt(457)); + assertTrue(ba.enthaelt(793)); + assertTrue(ba.enthaelt(209)); + assertTrue(ba.enthaelt(180)); + } + + @Test + public void test087() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(86)); + assertEquals(43,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(247)); + assertTrue(ba.enthaelt(787)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(117)); + assertFalse(ba.enthaelt(733)); + assertFalse(ba.enthaelt(565)); + assertFalse(ba.enthaelt(530)); + assertFalse(ba.enthaelt(363)); + assertFalse(ba.enthaelt(827)); + assertFalse(ba.enthaelt(995)); + assertFalse(ba.enthaelt(926)); + assertTrue(ba.enthaelt(294)); + assertTrue(ba.enthaelt(759)); + assertTrue(ba.enthaelt(972)); + assertTrue(ba.enthaelt(703)); + assertTrue(ba.enthaelt(739)); + assertTrue(ba.enthaelt(339)); + assertTrue(ba.enthaelt(589)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(450)); + } + + @Test + public void test088() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(87)); + assertEquals(579,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(1017)); + assertFalse(ba.enthaelt(557)); + assertTrue(ba.enthaelt(742)); + assertFalse(ba.enthaelt(95)); + assertFalse(ba.enthaelt(748)); + assertFalse(ba.enthaelt(839)); + assertFalse(ba.enthaelt(612)); + assertFalse(ba.enthaelt(131)); + assertTrue(ba.enthaelt(433)); + assertFalse(ba.enthaelt(64)); + assertFalse(ba.enthaelt(739)); + assertTrue(ba.enthaelt(831)); + assertTrue(ba.enthaelt(743)); + assertTrue(ba.enthaelt(368)); + assertFalse(ba.enthaelt(674)); + assertTrue(ba.enthaelt(889)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(435)); + assertTrue(ba.enthaelt(13)); + assertTrue(ba.enthaelt(350)); + } + + @Test + public void test089() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(88)); + assertEquals(229,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertTrue(ba.enthaelt(37)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(642)); + assertTrue(ba.enthaelt(83)); + assertFalse(ba.enthaelt(38)); + assertFalse(ba.enthaelt(859)); + assertTrue(ba.enthaelt(324)); + assertFalse(ba.enthaelt(475)); + assertTrue(ba.enthaelt(793)); + assertFalse(ba.enthaelt(472)); + assertFalse(ba.enthaelt(81)); + assertFalse(ba.enthaelt(480)); + assertFalse(ba.enthaelt(954)); + assertFalse(ba.enthaelt(466)); + assertTrue(ba.enthaelt(984)); + assertTrue(ba.enthaelt(540)); + assertTrue(ba.enthaelt(316)); + assertTrue(ba.enthaelt(721)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(517)); + } + + @Test + public void test090() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(89)); + assertEquals(159,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertTrue(ba.enthaelt(686)); + assertFalse(ba.enthaelt(84)); + assertFalse(ba.enthaelt(210)); + assertFalse(ba.enthaelt(541)); + assertTrue(ba.enthaelt(775)); + assertFalse(ba.enthaelt(429)); + assertFalse(ba.enthaelt(781)); + assertFalse(ba.enthaelt(133)); + assertTrue(ba.enthaelt(578)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(750)); + assertFalse(ba.enthaelt(295)); + assertFalse(ba.enthaelt(19)); + assertTrue(ba.enthaelt(278)); + assertTrue(ba.enthaelt(189)); + assertTrue(ba.enthaelt(826)); + assertTrue(ba.enthaelt(511)); + assertTrue(ba.enthaelt(999)); + assertTrue(ba.enthaelt(731)); + assertTrue(ba.enthaelt(39)); + } + + @Test + public void test091() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(90)); + assertEquals(329,ba.anzahl()); + assertEquals(11,ba.tiefe()); + assertFalse(ba.enthaelt(161)); + assertFalse(ba.enthaelt(698)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(204)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(467)); + assertTrue(ba.enthaelt(42)); + assertFalse(ba.enthaelt(897)); + assertTrue(ba.enthaelt(533)); + assertFalse(ba.enthaelt(864)); + assertTrue(ba.enthaelt(538)); + assertFalse(ba.enthaelt(142)); + assertFalse(ba.enthaelt(667)); + assertTrue(ba.enthaelt(783)); + assertTrue(ba.enthaelt(422)); + assertTrue(ba.enthaelt(48)); + assertTrue(ba.enthaelt(81)); + assertTrue(ba.enthaelt(478)); + assertTrue(ba.enthaelt(99)); + assertTrue(ba.enthaelt(834)); + } + + @Test + public void test092() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(91)); + assertEquals(87,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(77)); + assertTrue(ba.enthaelt(369)); + assertFalse(ba.enthaelt(596)); + assertFalse(ba.enthaelt(777)); + assertFalse(ba.enthaelt(899)); + assertFalse(ba.enthaelt(901)); + assertFalse(ba.enthaelt(985)); + assertFalse(ba.enthaelt(891)); + assertFalse(ba.enthaelt(785)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(98)); + assertTrue(ba.enthaelt(996)); + assertTrue(ba.enthaelt(356)); + assertTrue(ba.enthaelt(688)); + assertTrue(ba.enthaelt(746)); + assertTrue(ba.enthaelt(554)); + assertTrue(ba.enthaelt(92)); + assertTrue(ba.enthaelt(238)); + assertTrue(ba.enthaelt(779)); + assertTrue(ba.enthaelt(105)); + } + + @Test + public void test093() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(92)); + assertEquals(99,ba.anzahl()); + assertEquals(8,ba.tiefe()); + assertFalse(ba.enthaelt(185)); + assertFalse(ba.enthaelt(447)); + assertFalse(ba.enthaelt(401)); + assertFalse(ba.enthaelt(86)); + assertFalse(ba.enthaelt(744)); + assertFalse(ba.enthaelt(535)); + assertFalse(ba.enthaelt(886)); + assertFalse(ba.enthaelt(775)); + assertFalse(ba.enthaelt(810)); + assertFalse(ba.enthaelt(988)); + assertTrue(ba.enthaelt(67)); + assertTrue(ba.enthaelt(678)); + assertTrue(ba.enthaelt(50)); + assertTrue(ba.enthaelt(144)); + assertTrue(ba.enthaelt(959)); + assertTrue(ba.enthaelt(448)); + assertTrue(ba.enthaelt(636)); + assertTrue(ba.enthaelt(633)); + assertTrue(ba.enthaelt(296)); + assertTrue(ba.enthaelt(947)); + } + + @Test + public void test094() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(93)); + assertEquals(137,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(965)); + assertFalse(ba.enthaelt(826)); + assertFalse(ba.enthaelt(551)); + assertFalse(ba.enthaelt(651)); + assertFalse(ba.enthaelt(740)); + assertFalse(ba.enthaelt(993)); + assertFalse(ba.enthaelt(11)); + assertFalse(ba.enthaelt(497)); + assertFalse(ba.enthaelt(700)); + assertFalse(ba.enthaelt(177)); + assertTrue(ba.enthaelt(125)); + assertTrue(ba.enthaelt(816)); + assertTrue(ba.enthaelt(26)); + assertTrue(ba.enthaelt(80)); + assertTrue(ba.enthaelt(824)); + assertTrue(ba.enthaelt(381)); + assertTrue(ba.enthaelt(687)); + assertTrue(ba.enthaelt(37)); + assertTrue(ba.enthaelt(943)); + assertTrue(ba.enthaelt(363)); + } + + @Test + public void test095() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(94)); + assertEquals(357,ba.anzahl()); + assertEquals(12,ba.tiefe()); + assertFalse(ba.enthaelt(229)); + assertFalse(ba.enthaelt(313)); + assertTrue(ba.enthaelt(769)); + assertFalse(ba.enthaelt(74)); + assertFalse(ba.enthaelt(936)); + assertFalse(ba.enthaelt(373)); + assertFalse(ba.enthaelt(473)); + assertFalse(ba.enthaelt(694)); + assertFalse(ba.enthaelt(663)); + assertTrue(ba.enthaelt(391)); + assertTrue(ba.enthaelt(225)); + assertTrue(ba.enthaelt(783)); + assertFalse(ba.enthaelt(224)); + assertFalse(ba.enthaelt(531)); + assertTrue(ba.enthaelt(625)); + assertTrue(ba.enthaelt(186)); + assertTrue(ba.enthaelt(442)); + assertTrue(ba.enthaelt(374)); + assertTrue(ba.enthaelt(597)); + assertTrue(ba.enthaelt(999)); + } + + @Test + public void test096() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(95)); + assertEquals(79,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(630)); + assertFalse(ba.enthaelt(193)); + assertFalse(ba.enthaelt(100)); + assertFalse(ba.enthaelt(73)); + assertFalse(ba.enthaelt(926)); + assertFalse(ba.enthaelt(417)); + assertFalse(ba.enthaelt(214)); + assertTrue(ba.enthaelt(63)); + assertFalse(ba.enthaelt(329)); + assertFalse(ba.enthaelt(246)); + assertFalse(ba.enthaelt(934)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(256)); + assertTrue(ba.enthaelt(655)); + assertTrue(ba.enthaelt(441)); + assertTrue(ba.enthaelt(927)); + assertTrue(ba.enthaelt(74)); + assertTrue(ba.enthaelt(576)); + assertTrue(ba.enthaelt(702)); + assertTrue(ba.enthaelt(333)); + } + + @Test + public void test097() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(96)); + assertEquals(141,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(98)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(169)); + assertFalse(ba.enthaelt(917)); + assertFalse(ba.enthaelt(103)); + assertFalse(ba.enthaelt(15)); + assertFalse(ba.enthaelt(931)); + assertFalse(ba.enthaelt(265)); + assertFalse(ba.enthaelt(226)); + assertTrue(ba.enthaelt(639)); + assertFalse(ba.enthaelt(775)); + assertTrue(ba.enthaelt(150)); + assertTrue(ba.enthaelt(183)); + assertTrue(ba.enthaelt(281)); + assertTrue(ba.enthaelt(510)); + assertTrue(ba.enthaelt(428)); + assertTrue(ba.enthaelt(631)); + assertTrue(ba.enthaelt(221)); + assertTrue(ba.enthaelt(533)); + assertTrue(ba.enthaelt(12)); + } + + @Test + public void test098() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(97)); + assertEquals(139,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(889)); + assertFalse(ba.enthaelt(987)); + assertFalse(ba.enthaelt(441)); + assertFalse(ba.enthaelt(33)); + assertFalse(ba.enthaelt(485)); + assertFalse(ba.enthaelt(482)); + assertFalse(ba.enthaelt(946)); + assertFalse(ba.enthaelt(299)); + assertFalse(ba.enthaelt(227)); + assertFalse(ba.enthaelt(147)); + assertTrue(ba.enthaelt(763)); + assertTrue(ba.enthaelt(63)); + assertTrue(ba.enthaelt(169)); + assertTrue(ba.enthaelt(57)); + assertTrue(ba.enthaelt(100)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(401)); + assertTrue(ba.enthaelt(301)); + assertTrue(ba.enthaelt(214)); + assertTrue(ba.enthaelt(30)); + } + + @Test + public void test099() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(98)); + assertEquals(169,ba.anzahl()); + assertEquals(10,ba.tiefe()); + assertFalse(ba.enthaelt(896)); + assertFalse(ba.enthaelt(714)); + assertTrue(ba.enthaelt(308)); + assertTrue(ba.enthaelt(597)); + assertFalse(ba.enthaelt(354)); + assertFalse(ba.enthaelt(760)); + assertTrue(ba.enthaelt(610)); + assertFalse(ba.enthaelt(411)); + assertFalse(ba.enthaelt(259)); + assertFalse(ba.enthaelt(127)); + assertFalse(ba.enthaelt(541)); + assertFalse(ba.enthaelt(269)); + assertFalse(ba.enthaelt(379)); + assertTrue(ba.enthaelt(322)); + assertTrue(ba.enthaelt(670)); + assertTrue(ba.enthaelt(568)); + assertTrue(ba.enthaelt(156)); + assertTrue(ba.enthaelt(882)); + assertTrue(ba.enthaelt(952)); + assertTrue(ba.enthaelt(102)); + } + + @Test + public void test100() + { + Baumalgorithmen ba = new Baumalgorithmen(Testbaeume.getTestBaum(99)); + assertEquals(119,ba.anzahl()); + assertEquals(9,ba.tiefe()); + assertFalse(ba.enthaelt(334)); + assertFalse(ba.enthaelt(0)); + assertFalse(ba.enthaelt(307)); + assertFalse(ba.enthaelt(572)); + assertFalse(ba.enthaelt(273)); + assertFalse(ba.enthaelt(644)); + assertFalse(ba.enthaelt(671)); + assertFalse(ba.enthaelt(976)); + assertFalse(ba.enthaelt(1007)); + assertFalse(ba.enthaelt(697)); + assertTrue(ba.enthaelt(968)); + assertTrue(ba.enthaelt(33)); + assertTrue(ba.enthaelt(411)); + assertTrue(ba.enthaelt(780)); + assertTrue(ba.enthaelt(387)); + assertTrue(ba.enthaelt(263)); + assertTrue(ba.enthaelt(396)); + assertTrue(ba.enthaelt(198)); + assertTrue(ba.enthaelt(6)); + assertTrue(ba.enthaelt(28)); + } + + + @Test + public void fdg() + { + Binaerbaum binaerba1 = Testbaeume.getTestBaum(1); + assertEquals(null, binaerba1); + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/BaumTester2.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/BaumTester2.java new file mode 100644 index 0000000..baa5633 --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/BaumTester2.java @@ -0,0 +1,13201 @@ +import static org.junit.Assert.*; +import org.junit.Test; + +/** + * Testet Tiefen- und Breitensuche + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class BaumTester2 +{ + @Test + public void testEnthaelt001() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(0)); + Integer e; + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(789, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(789, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(400, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(270, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(766, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(255, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(259, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(76, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(71, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(468, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + } + + @Test + public void testEnthaelt002() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(1)); + Integer e; + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(275, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(273, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(950, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(958, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(409, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(409, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(604, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(996, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(506, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(692, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(286, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(286, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(37, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.breitensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.tiefensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.breitensuche(x -> (x >= 160 && x < 170))); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(913, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(558, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(825, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + } + + @Test + public void testEnthaelt003() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(2)); + Integer e; + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(649, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(629, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(628, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(66, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(69, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(954, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(221, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(656, e.intValue()); + } + + @Test + public void testEnthaelt004() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(3)); + Integer e; + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(69, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(652, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(656, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(619, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(619, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(120, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(351, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(394, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(669, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(664, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(304, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(305, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(189, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(183, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + } + + @Test + public void testEnthaelt005() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(4)); + Integer e; + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(99, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(55, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(55, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(372, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(374, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.tiefensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.breitensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.tiefensuche(x -> (x >= 830 && x < 840))); + assertNull(ba.breitensuche(x -> (x >= 830 && x < 840))); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(581, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(586, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(134, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(133, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + } + + @Test + public void testEnthaelt006() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(5)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.breitensuche(x -> (x >= 640 && x < 650))); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(909, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.breitensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.tiefensuche(x -> (x >= 150 && x < 160))); + assertNull(ba.breitensuche(x -> (x >= 150 && x < 160))); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(624, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(624, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(780, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(787, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(601, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(601, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(423, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(757, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(373, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(372, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(74, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(865, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + } + + @Test + public void testEnthaelt007() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(6)); + Integer e; + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(599, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(645, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(642, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(496, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(625, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(606, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(606, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(182, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(181, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(908, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(990, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + } + + @Test + public void testEnthaelt008() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(7)); + Integer e; + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(259, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(452, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(568, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(296, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(293, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(897, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(897, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(572, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(574, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(13, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(14, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(202, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(165, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(677, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(677, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(224, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(224, e.intValue()); + } + + @Test + public void testEnthaelt009() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(8)); + Integer e; + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(531, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(75, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 520 && x < 530))); + assertNull(ba.breitensuche(x -> (x >= 520 && x < 530))); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(457, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(459, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(944, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(944, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.breitensuche(x -> (x >= 500 && x < 510))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(952, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(866, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(483, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(987, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(582, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(582, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(464, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(464, e.intValue()); + } + + @Test + public void testEnthaelt010() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(9)); + Integer e; + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 340 && x < 350))); + assertNull(ba.breitensuche(x -> (x >= 340 && x < 350))); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(296, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(293, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(848, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(757, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(88, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(88, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(939, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(360, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(411, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(805, e.intValue()); + } + + @Test + public void testEnthaelt011() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(10)); + Integer e; + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(170, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(170, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(478, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(383, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(922, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(197, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(835, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(839, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(971, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(238, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(690, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(24, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 510 && x < 520))); + assertNull(ba.breitensuche(x -> (x >= 510 && x < 520))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.breitensuche(x -> (x >= 160 && x < 170))); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.breitensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + } + + @Test + public void testEnthaelt012() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(11)); + Integer e; + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(563, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(563, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(92, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(114, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(917, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(917, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(621, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(628, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.breitensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + } + + @Test + public void testEnthaelt013() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(12)); + Integer e; + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(279, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(273, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(611, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(124, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(124, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 380 && x < 390))); + assertNull(ba.breitensuche(x -> (x >= 380 && x < 390))); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(179, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.breitensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(782, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(911, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(45, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(91, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(91, e.intValue()); + } + + @Test + public void testEnthaelt014() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(13)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(106, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(106, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(902, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(291, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(517, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(943, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(940, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + } + + @Test + public void testEnthaelt015() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(14)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(888, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(257, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(255, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(518, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(21, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(20, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(99, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(92, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(776, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(123, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(31, e.intValue()); + } + + @Test + public void testEnthaelt016() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(15)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.breitensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(342, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(342, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(52, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(52, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(636, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(636, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(730, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(730, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(591, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(152, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(152, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(310, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(426, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(121, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(762, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(856, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(723, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(231, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(775, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + } + + @Test + public void testEnthaelt017() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(16)); + Integer e; + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 500 && x < 510))); + assertNull(ba.breitensuche(x -> (x >= 500 && x < 510))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(783, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(806, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(115, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.breitensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(812, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(103, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(107, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(357, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + } + + @Test + public void testEnthaelt018() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(17)); + Integer e; + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(974, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(180, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(180, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(231, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(825, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(651, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(136, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(132, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(922, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(885, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(885, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(378, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(378, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(440, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(440, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.tiefensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.breitensuche(x -> (x >= 400 && x < 410))); + } + + @Test + public void testEnthaelt019() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(18)); + Integer e; + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(3, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(3, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(431, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(431, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(325, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(329, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(647, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + + assertEquals(222, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(238, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(238, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(466, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(290, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(574, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(47, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(637, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(195, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.breitensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.tiefensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.breitensuche(x -> (x >= 770 && x < 780))); + assertNull(ba.tiefensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.breitensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.tiefensuche(x -> (x >= 510 && x < 520))); + assertNull(ba.breitensuche(x -> (x >= 510 && x < 520))); + } + + @Test + public void testEnthaelt020() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(19)); + Integer e; + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(758, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(758, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(931, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(931, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(187, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(187, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(712, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(791, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(791, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(14, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(765, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(522, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(528, e.intValue()); + } + + @Test + public void testEnthaelt021() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(20)); + Integer e; + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(971, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(971, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(395, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(196, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(192, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(850, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(586, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(584, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + } + + @Test + public void testEnthaelt022() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(21)); + Integer e; + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(19, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(666, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(666, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(320, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(320, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(382, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(692, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(693, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(261, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(267, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(867, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(674, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(674, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(68, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(68, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(975, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.breitensuche(x -> (x >= 50 && x < 60))); + } + + @Test + public void testEnthaelt023() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(22)); + Integer e; + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(266, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(190, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(413, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.breitensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(950, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(913, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(609, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(677, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(662, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(47, e.intValue()); + } + + @Test + public void testEnthaelt024() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(23)); + Integer e; + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(953, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(953, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(67, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(700, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 850 && x < 860))); + assertNull(ba.breitensuche(x -> (x >= 850 && x < 860))); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(882, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.breitensuche(x -> (x >= 730 && x < 740))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(248, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(761, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(802, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(805, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + } + + @Test + public void testEnthaelt025() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(24)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 30 && x < 40))); + assertNull(ba.breitensuche(x -> (x >= 30 && x < 40))); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(211, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(211, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(507, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(125, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(296, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(834, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(949, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(692, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(782, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + } + + @Test + public void testEnthaelt026() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(25)); + Integer e; + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(684, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(684, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(652, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(652, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(948, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(948, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(876, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(264, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(393, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(507, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.breitensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.tiefensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.breitensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.tiefensuche(x -> (x >= 50 && x < 60))); + assertNull(ba.breitensuche(x -> (x >= 50 && x < 60))); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(861, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(860, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + } + + @Test + public void testEnthaelt027() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(26)); + Integer e; + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(443, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(460, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(460, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(67, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(68, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(310, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(310, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(584, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(581, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(403, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(403, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 20 && x < 30))); + assertNull(ba.breitensuche(x -> (x >= 20 && x < 30))); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(673, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(673, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(284, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(281, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(934, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + } + + @Test + public void testEnthaelt028() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(27)); + Integer e; + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(321, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(321, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(976, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(978, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(707, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(398, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(221, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(745, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(204, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.breitensuche(x -> (x >= 280 && x < 290))); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(169, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + } + + @Test + public void testEnthaelt029() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(28)); + Integer e; + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(549, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(59, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(59, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(137, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(137, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(503, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(818, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + } + + @Test + public void testEnthaelt030() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(29)); + Integer e; + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(242, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(910, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(910, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(700, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(848, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(841, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(10, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(14, e.intValue()); + } + + @Test + public void testEnthaelt031() + { + + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(30)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(427, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(427, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 240 && x < 250))); + assertNull(ba.breitensuche(x -> (x >= 240 && x < 250))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(287, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(287, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(957, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(953, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(115, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(660, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(91, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(689, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(908, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(41, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(888, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + } + + @Test + public void testEnthaelt032() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(31)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.breitensuche(x -> (x >= 470 && x < 480))); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(625, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(625, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(306, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(800, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(800, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.tiefensuche(x -> (x >= 830 && x < 840))); + assertNull(ba.breitensuche(x -> (x >= 830 && x < 840))); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(198, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(111, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(443, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(949, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(642, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(547, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + } + + @Test + public void testEnthaelt033() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(32)); + Integer e; + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(37, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(34, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(317, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(114, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(239, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(493, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(431, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(152, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(421, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(421, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(369, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + } + + @Test + public void testEnthaelt034() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(33)); + Integer e; + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(132, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(132, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.breitensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 510 && x < 520))); + assertNull(ba.breitensuche(x -> (x >= 510 && x < 520))); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(107, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(107, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(195, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(192, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(771, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(771, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(957, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(21, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(581, e.intValue()); + } + + @Test + public void testEnthaelt035() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(34)); + Integer e; + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(145, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(249, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(58, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(781, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(829, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(661, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(667, e.intValue()); + } + + @Test + public void testEnthaelt036() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(35)); + Integer e; + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(846, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(846, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(859, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(915, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(915, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.breitensuche(x -> (x >= 100 && x < 110))); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(250, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(326, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(321, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(546, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(546, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(516, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(439, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(929, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(28, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(23, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(93, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + } + + @Test + public void testEnthaelt037() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(36)); + Integer e; + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(579, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(65, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(826, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(826, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(83, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(201, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(159, e.intValue()); + } + + @Test + public void testEnthaelt038() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(37)); + Integer e; + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(533, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(980, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(5, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(751, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(133, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(255, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(740, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(743, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.breitensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + } + + @Test + public void testEnthaelt039() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(38)); + Integer e; + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(609, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(35, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(35, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(592, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.breitensuche(x -> (x >= 960 && x < 970))); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(303, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(304, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 360 && x < 370))); + assertNull(ba.breitensuche(x -> (x >= 360 && x < 370))); + assertNull(ba.tiefensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.breitensuche(x -> (x >= 540 && x < 550))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(789, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(353, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(357, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(426, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(422, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(146, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + } + + @Test + public void testEnthaelt040() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(39)); + Integer e; + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(13, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(13, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(73, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(614, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(615, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(462, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(792, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(621, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(168, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(809, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(806, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(710, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(710, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(683, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(683, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(992, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(90, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(90, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + } + + @Test + public void testEnthaelt041() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(40)); + Integer e; + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(25, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(25, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(199, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(689, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(587, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(587, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.tiefensuche(x -> (x >= 360 && x < 370))); + assertNull(ba.breitensuche(x -> (x >= 360 && x < 370))); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(980, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(980, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(730, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(290, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(700, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(403, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(345, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(413, e.intValue()); + } + + @Test + public void testEnthaelt042() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(41)); + Integer e; + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(6, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(378, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(552, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(552, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.breitensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.tiefensuche(x -> (x >= 410 && x < 420))); + assertNull(ba.breitensuche(x -> (x >= 410 && x < 420))); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(236, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(825, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(461, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(464, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(928, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(387, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(765, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + } + + @Test + public void testEnthaelt043() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(42)); + Integer e; + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(998, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(998, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(467, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(467, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(628, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(449, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(814, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 800 && x < 810))); + assertNull(ba.breitensuche(x -> (x >= 800 && x < 810))); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(634, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(478, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(675, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(676, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(838, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(838, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(78, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(78, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(353, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(236, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 0 && x < 10))); + assertNull(ba.breitensuche(x -> (x >= 0 && x < 10))); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.tiefensuche(x -> (x >= 200 && x < 210))); + assertNull(ba.breitensuche(x -> (x >= 200 && x < 210))); + } + + @Test + public void testEnthaelt044() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(43)); + Integer e; + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(499, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(499, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(517, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(832, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(821, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(40, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(47, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(756, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(751, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(58, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(51, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(801, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + } + + @Test + public void testEnthaelt045() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(44)); + Integer e; + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(661, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(664, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(937, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(405, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(74, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(479, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(42, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(41, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(752, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(752, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(622, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(237, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(729, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(729, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + } + + @Test + public void testEnthaelt046() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(45)); + Integer e; + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(880, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(880, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(718, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(526, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(545, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(584, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(457, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(732, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(879, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(78, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(320, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 420 && x < 430))); + assertNull(ba.breitensuche(x -> (x >= 420 && x < 430))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(472, e.intValue()); + } + + @Test + public void testEnthaelt047() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(46)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(178, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(175, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(299, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(299, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(528, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(528, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(433, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(636, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(630, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(715, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(23, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(22, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(748, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(866, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(860, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(570, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(194, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(199, e.intValue()); + } + + @Test + public void testEnthaelt048() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(47)); + Integer e; + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(484, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(921, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(922, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 150 && x < 160))); + assertNull(ba.breitensuche(x -> (x >= 150 && x < 160))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(835, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(835, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(944, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(940, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(221, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(19, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(719, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(719, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(86, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(776, e.intValue()); + } + + @Test + public void testEnthaelt049() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(48)); + Integer e; + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(137, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(716, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(713, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(220, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(441, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(347, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(341, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(141, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(382, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(66, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(240, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(359, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(359, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(888, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(886, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(924, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(436, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(893, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(893, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + } + + @Test + public void testEnthaelt050() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(49)); + Integer e; + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(168, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.breitensuche(x -> (x >= 620 && x < 630))); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.tiefensuche(x -> (x >= 680 && x < 690))); + assertNull(ba.breitensuche(x -> (x >= 680 && x < 690))); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(123, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(123, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(314, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(331, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(568, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(567, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(133, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(139, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(731, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(503, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(502, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(143, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(148, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(656, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + } + + @Test + public void testEnthaelt051() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(50)); + Integer e; + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(937, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(937, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(911, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(911, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(204, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(204, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.breitensuche(x -> (x >= 940 && x < 950))); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(301, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(301, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(772, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(891, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(90, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(97, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(607, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(843, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(329, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(326, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(967, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + } + + @Test + public void testEnthaelt052() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(51)); + Integer e; + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(120, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(188, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(185, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(666, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(579, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(826, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(89, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(791, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(950, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + } + + @Test + public void testEnthaelt053() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(52)); + Integer e; + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(740, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(743, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(263, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(774, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(247, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(247, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(400, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(108, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(108, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(468, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(393, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(393, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(632, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(64, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(494, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(585, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(585, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + } + + @Test + public void testEnthaelt054() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(53)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.breitensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(264, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(264, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(126, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(126, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(44, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(795, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(795, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(577, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(861, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 310 && x < 320))); + assertNull(ba.breitensuche(x -> (x >= 310 && x < 320))); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(233, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(233, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.tiefensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.breitensuche(x -> (x >= 580 && x < 590)); + assertNotNull(e); + assertEquals(589, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(497, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(112, e.intValue()); + } + + @Test + public void testEnthaelt055() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(54)); + Integer e; + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(872, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(872, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(933, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(561, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(599, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(446, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(918, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(915, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(315, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(742, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(507, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(504, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(279, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.tiefensuche(x -> (x >= 30 && x < 40))); + assertNull(ba.breitensuche(x -> (x >= 30 && x < 40))); + } + + @Test + public void testEnthaelt056() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(55)); + Integer e; + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.breitensuche(x -> (x >= 160 && x < 170))); + assertNull(ba.tiefensuche(x -> (x >= 290 && x < 300))); + assertNull(ba.breitensuche(x -> (x >= 290 && x < 300))); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(54, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(54, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(476, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(411, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(69, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 870 && x < 880))); + assertNull(ba.breitensuche(x -> (x >= 870 && x < 880))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(859, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(859, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(806, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(788, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(355, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(355, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(385, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(384, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(760, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + } + + @Test + public void testEnthaelt057() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(56)); + Integer e; + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(619, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(891, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 570 && x < 580))); + assertNull(ba.breitensuche(x -> (x >= 570 && x < 580))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(531, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(535, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(428, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(426, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(762, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(105, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(108, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(974, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(975, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(116, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(116, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + } + + @Test + public void testEnthaelt058() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(57)); + Integer e; + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.breitensuche(x -> (x >= 550 && x < 560))); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(477, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(727, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(315, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(419, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(163, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(291, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(987, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(7, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(337, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + } + + @Test + public void testEnthaelt059() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(58)); + Integer e; + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(708, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(709, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(954, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(957, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(215, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(641, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(891, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(197, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(196, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(610, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(610, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(518, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(778, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(724, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(726, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(56, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(53, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(875, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + } + + @Test + public void testEnthaelt060() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(59)); + Integer e; + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(719, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(900, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(900, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(148, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(148, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(195, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(624, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(462, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(462, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(8, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(8, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(771, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.breitensuche(x -> (x >= 60 && x < 70))); + assertNull(ba.tiefensuche(x -> (x >= 800 && x < 810))); + assertNull(ba.breitensuche(x -> (x >= 800 && x < 810))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(81, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(89, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(452, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(482, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 40 && x < 50))); + assertNull(ba.breitensuche(x -> (x >= 40 && x < 50))); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + } + + @Test + public void testEnthaelt061() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(60)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.breitensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(4, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(9, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 340 && x < 350))); + assertNull(ba.breitensuche(x -> (x >= 340 && x < 350))); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(557, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(494, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(494, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(845, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(958, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(690, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(690, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(201, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(639, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(630, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(878, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(370, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(376, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(391, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + } + + @Test + public void testEnthaelt062() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(61)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 590 && x < 600))); + assertNull(ba.breitensuche(x -> (x >= 590 && x < 600))); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(298, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.tiefensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.breitensuche(x -> (x >= 760 && x < 770))); + assertNull(ba.tiefensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.breitensuche(x -> (x >= 650 && x < 660))); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(681, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(681, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(785, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(989, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(989, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(809, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(809, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(272, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(579, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(317, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(319, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(836, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(836, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(75, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(755, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(330, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(169, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(260, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + } + + @Test + public void testEnthaelt063() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(62)); + Integer e; + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(932, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(932, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(766, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(15, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(820, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(820, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(567, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(567, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(836, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(839, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(552, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(490, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(515, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(958, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(940, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(682, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(295, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(297, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.tiefensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.breitensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.tiefensuche(x -> (x >= 980 && x < 990))); + assertNull(ba.breitensuche(x -> (x >= 980 && x < 990))); + } + + @Test + public void testEnthaelt064() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(63)); + Integer e; + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.breitensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.tiefensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.breitensuche(x -> (x >= 880 && x < 890))); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 700 && x < 710))); + assertNull(ba.breitensuche(x -> (x >= 700 && x < 710))); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(838, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(210, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(242, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(242, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(926, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(824, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(112, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(116, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(308, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(333, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(607, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(35, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(38, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(800, e.intValue()); + } + + @Test + public void testEnthaelt065() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(64)); + Integer e; + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(591, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(315, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(120, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(934, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(300, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(781, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(787, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(870, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(445, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(445, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + } + + @Test + public void testEnthaelt066() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(65)); + Integer e; + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.breitensuche(x -> (x >= 920 && x < 930))); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.tiefensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.breitensuche(x -> (x >= 350 && x < 360))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(696, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(696, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(245, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(855, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(517, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(228, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(500, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(509, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(472, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(338, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(330, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(779, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(778, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(820, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + } + + @Test + public void testEnthaelt067() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(66)); + Integer e; + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 740 && x < 750))); + assertNull(ba.breitensuche(x -> (x >= 740 && x < 750))); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(292, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(276, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(277, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(833, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(646, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 400 && x < 410))); + assertNull(ba.breitensuche(x -> (x >= 400 && x < 410))); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(695, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(693, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(351, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.breitensuche(x -> (x >= 650 && x < 660))); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(451, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(931, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(181, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(186, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(174, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(503, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + } + + @Test + public void testEnthaelt068() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(67)); + Integer e; + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(850, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(182, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(182, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(475, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(670, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(670, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(372, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(89, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(706, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(100, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(873, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(796, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + } + + @Test + public void testEnthaelt069() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(68)); + Integer e; + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(158, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(532, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(531, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(741, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(352, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(483, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(484, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(701, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(701, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(223, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(227, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(256, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(251, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(733, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(114, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(802, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + } + + @Test + public void testEnthaelt070() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(69)); + Integer e; + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(241, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(908, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(904, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(434, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(473, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(280, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(149, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(549, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(422, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(895, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(892, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(946, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.tiefensuche(x -> (x >= 780 && x < 790))); + assertNull(ba.breitensuche(x -> (x >= 780 && x < 790))); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + } + + @Test + public void testEnthaelt071() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(70)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.breitensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(682, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(259, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(258, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(38, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(559, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(212, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(335, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(775, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(521, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(379, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(360, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(360, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(267, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(269, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(235, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(353, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(354, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 790 && x < 800))); + assertNull(ba.breitensuche(x -> (x >= 790 && x < 800))); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + } + + @Test + public void testEnthaelt072() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(71)); + Integer e; + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(140, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(928, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(928, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(801, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(801, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(901, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(847, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(793, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(794, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(827, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(816, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(222, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.tiefensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.breitensuche(x -> (x >= 90 && x < 100))); + assertNull(ba.tiefensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.breitensuche(x -> (x >= 460 && x < 470))); + assertNull(ba.tiefensuche(x -> (x >= 420 && x < 430))); + assertNull(ba.breitensuche(x -> (x >= 420 && x < 430))); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(913, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(41, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(160, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(161, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(363, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(75, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(71, e.intValue()); + } + + @Test + public void testEnthaelt073() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(72)); + Integer e; + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(529, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(526, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(467, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(816, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(661, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(662, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.breitensuche(x -> (x >= 100 && x < 110))); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(932, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(939, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(571, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(902, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(902, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(332, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(371, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(375, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(418, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(506, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(500, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(0, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + } + + @Test + public void testEnthaelt074() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(73)); + Integer e; + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(982, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(509, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 580 && x < 590))); + assertNull(ba.breitensuche(x -> (x >= 580 && x < 590))); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(389, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(604, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(465, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(469, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(616, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(410, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(648, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(850, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(949, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(698, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(362, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(205, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(205, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(62, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 260 && x < 270))); + assertNull(ba.breitensuche(x -> (x >= 260 && x < 270))); + } + + @Test + public void testEnthaelt075() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(74)); + Integer e; + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(635, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(626, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(95, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(10, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(10, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(748, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(746, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.breitensuche(x -> (x >= 100 && x < 110))); + assertNull(ba.tiefensuche(x -> (x >= 420 && x < 430))); + assertNull(ba.breitensuche(x -> (x >= 420 && x < 430))); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(807, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(284, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(284, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(776, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(777, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(155, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(172, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(550, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(553, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(454, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(79, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(72, e.intValue()); + } + + @Test + public void testEnthaelt076() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(75)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 240 && x < 250))); + assertNull(ba.breitensuche(x -> (x >= 240 && x < 250))); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(419, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(419, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.tiefensuche(x -> (x >= 700 && x < 710))); + assertNull(ba.breitensuche(x -> (x >= 700 && x < 710))); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(614, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(614, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(600, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(956, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(956, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(747, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(997, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(993, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(929, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(925, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(660, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(664, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(208, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(964, e.intValue()); + } + + @Test + public void testEnthaelt077() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(76)); + Integer e; + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(563, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(565, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(42, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(40, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(998, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(992, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(52, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(58, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(591, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(16, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(16, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(135, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(217, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(522, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(461, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(461, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(749, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(457, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(857, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(851, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(651, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(960, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.breitensuche(x -> (x >= 880 && x < 890))); + assertNull(ba.tiefensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.breitensuche(x -> (x >= 940 && x < 950))); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + } + + @Test + public void testEnthaelt078() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(77)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 220 && x < 230))); + assertNull(ba.breitensuche(x -> (x >= 220 && x < 230))); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(519, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(300, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(307, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(98, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(884, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(485, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(483, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(271, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(65, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(65, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(878, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(870, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(615, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(617, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(495, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(766, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(211, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(214, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.breitensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.tiefensuche(x -> (x >= 850 && x < 860))); + assertNull(ba.breitensuche(x -> (x >= 850 && x < 860))); + } + + @Test + public void testEnthaelt079() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(78)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.tiefensuche(x -> (x >= 690 && x < 700))); + assertNull(ba.breitensuche(x -> (x >= 690 && x < 700))); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.breitensuche(x -> (x >= 650 && x < 660))); + assertNull(ba.tiefensuche(x -> (x >= 730 && x < 740))); + assertNull(ba.breitensuche(x -> (x >= 730 && x < 740))); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(444, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(444, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(327, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(326, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(348, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(348, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(831, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(831, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(977, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(716, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(716, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(436, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(436, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(796, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(32, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(32, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(416, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(415, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(497, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(287, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + } + + @Test + public void testEnthaelt080() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(79)); + Integer e; + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(792, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(917, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(644, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(31, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(248, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(248, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(374, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(373, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(534, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(511, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(511, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(934, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(941, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(218, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(219, e.intValue()); + e = ba.tiefensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(294, e.intValue()); + e = ba.breitensuche(x -> (x >= 290 && x < 300)); + assertNotNull(e); + assertEquals(295, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.breitensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.tiefensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.breitensuche(x -> (x >= 330 && x < 340))); + assertNull(ba.tiefensuche(x -> (x >= 350 && x < 360))); + assertNull(ba.breitensuche(x -> (x >= 350 && x < 360))); + } + + @Test + public void testEnthaelt081() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(80)); + Integer e; + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(157, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(252, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(254, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(697, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(694, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(612, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(822, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(975, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(979, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(387, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(573, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(768, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(765, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(671, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(982, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(455, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(458, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(889, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(283, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(206, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(206, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(930, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(930, e.intValue()); + } + + @Test + public void testEnthaelt082() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(81)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 610 && x < 620))); + assertNull(ba.breitensuche(x -> (x >= 610 && x < 620))); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(432, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(432, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(560, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(227, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(227, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(486, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(429, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 370 && x < 380))); + assertNull(ba.breitensuche(x -> (x >= 370 && x < 380))); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(797, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(358, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(876, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(876, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(85, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(408, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 240 && x < 250))); + assertNull(ba.breitensuche(x -> (x >= 240 && x < 250))); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(143, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(142, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(599, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(592, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(841, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(844, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(864, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(174, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(178, e.intValue()); + } + + @Test + public void testEnthaelt083() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(82)); + Integer e; + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(688, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(681, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(973, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(330, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(828, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(176, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(176, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(790, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(872, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(11, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(12, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(994, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(167, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(890, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(87, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(84, e.intValue()); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(77, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(77, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(96, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(96, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(672, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 640 && x < 650))); + assertNull(ba.breitensuche(x -> (x >= 640 && x < 650))); + } + + @Test + public void testEnthaelt084() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(83)); + Integer e; + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(604, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(608, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(704, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(111, e.intValue()); + e = ba.tiefensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(823, e.intValue()); + e = ba.breitensuche(x -> (x >= 820 && x < 830)); + assertNotNull(e); + assertEquals(823, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(136, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(136, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(810, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(694, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(694, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(535, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(535, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(919, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(918, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(232, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(627, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(128, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(46, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(965, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 320 && x < 330))); + assertNull(ba.breitensuche(x -> (x >= 320 && x < 330))); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(780, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(787, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(277, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(279, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.breitensuche(x -> (x >= 140 && x < 150))); + assertNull(ba.tiefensuche(x -> (x >= 990 && x < 1000))); + assertNull(ba.breitensuche(x -> (x >= 990 && x < 1000))); + assertNull(ba.tiefensuche(x -> (x >= 410 && x < 420))); + assertNull(ba.breitensuche(x -> (x >= 410 && x < 420))); + } + + @Test + public void testEnthaelt085() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(84)); + Integer e; + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(920, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(811, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(60, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(322, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(622, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(623, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(659, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.breitensuche(x -> (x >= 80 && x < 90))); + assertNull(ba.tiefensuche(x -> (x >= 740 && x < 750))); + assertNull(ba.breitensuche(x -> (x >= 740 && x < 750))); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(274, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(235, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(235, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(447, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(444, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(265, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(989, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(984, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(344, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(340, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(696, e.intValue()); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(359, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(356, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(720, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + } + + @Test + public void testEnthaelt086() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(85)); + Integer e; + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(480, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(481, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(803, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(425, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(421, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(961, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(961, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(896, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(527, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(522, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(244, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(129, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(129, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(226, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(275, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(275, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(714, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(602, e.intValue()); + e = ba.tiefensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(304, e.intValue()); + e = ba.breitensuche(x -> (x >= 300 && x < 310)); + assertNotNull(e); + assertEquals(309, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(751, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(206, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + } + + @Test + public void testEnthaelt087() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(86)); + Integer e; + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(991, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.tiefensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.breitensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(349, e.intValue()); + e = ba.tiefensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(184, e.intValue()); + e = ba.breitensuche(x -> (x >= 180 && x < 190)); + assertNotNull(e); + assertEquals(184, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(450, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(703, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(796, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(799, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(280, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(280, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(590, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(618, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(735, e.intValue()); + e = ba.tiefensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(524, e.intValue()); + e = ba.breitensuche(x -> (x >= 520 && x < 530)); + assertNotNull(e); + assertEquals(523, e.intValue()); + } + + @Test + public void testEnthaelt088() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(87)); + Integer e; + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(693, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(699, e.intValue()); + e = ba.tiefensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.breitensuche(x -> (x >= 740 && x < 750)); + assertNotNull(e); + assertEquals(744, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(548, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(544, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(424, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(423, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(669, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(668, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(753, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(754, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(551, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(387, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(48, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(342, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(343, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(233, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(234, e.intValue()); + e = ba.tiefensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(442, e.intValue()); + e = ba.breitensuche(x -> (x >= 440 && x < 450)); + assertNotNull(e); + assertEquals(440, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(368, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(368, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(173, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(339, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + } + + @Test + public void testEnthaelt089() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(88)); + Integer e; + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(540, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(873, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(873, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(311, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(313, e.intValue()); + e = ba.tiefensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(178, e.intValue()); + e = ba.breitensuche(x -> (x >= 170 && x < 180)); + assertNotNull(e); + assertEquals(177, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(489, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(487, e.intValue()); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(327, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(479, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(479, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(155, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(653, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(613, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 910 && x < 920))); + assertNull(ba.breitensuche(x -> (x >= 910 && x < 920))); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(759, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(117, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(112, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(96, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(94, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(2, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(395, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(390, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.breitensuche(x -> (x >= 670 && x < 680))); + assertNull(ba.tiefensuche(x -> (x >= 630 && x < 640))); + assertNull(ba.breitensuche(x -> (x >= 630 && x < 640))); + } + + @Test + public void testEnthaelt090() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(89)); + Integer e; + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(969, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(962, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 540 && x < 550))); + assertNull(ba.breitensuche(x -> (x >= 540 && x < 550))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(815, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 430 && x < 440))); + assertNull(ba.breitensuche(x -> (x >= 430 && x < 440))); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(598, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(597, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 70 && x < 80))); + assertNull(ba.breitensuche(x -> (x >= 70 && x < 80))); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(898, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(138, e.intValue()); + e = ba.breitensuche(x -> (x >= 130 && x < 140)); + assertNotNull(e); + assertEquals(131, e.intValue()); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(336, e.intValue()); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(578, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(578, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(511, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(516, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(225, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(404, e.intValue()); + e = ba.tiefensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(213, e.intValue()); + e = ba.breitensuche(x -> (x >= 210 && x < 220)); + assertNotNull(e); + assertEquals(216, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(278, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(101, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(346, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(367, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(756, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(756, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(609, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(605, e.intValue()); + e = ba.tiefensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(995, e.intValue()); + e = ba.breitensuche(x -> (x >= 990 && x < 1000)); + assertNotNull(e); + assertEquals(999, e.intValue()); + } + + @Test + public void testEnthaelt091() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(90)); + Integer e; + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(498, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(491, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(361, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(863, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(972, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(978, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(397, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(399, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(853, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(76, e.intValue()); + e = ba.breitensuche(x -> (x >= 70 && x < 80)); + assertNotNull(e); + assertEquals(70, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(556, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(49, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(569, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(562, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(505, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(508, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(663, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(668, e.intValue()); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(246, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(246, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(784, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(695, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(695, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(50, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(50, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(29, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(118, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.breitensuche(x -> (x >= 480 && x < 490))); + assertNull(ba.tiefensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.breitensuche(x -> (x >= 230 && x < 240))); + assertNull(ba.tiefensuche(x -> (x >= 180 && x < 190))); + assertNull(ba.breitensuche(x -> (x >= 180 && x < 190))); + } + + @Test + public void testEnthaelt092() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(91)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + e = ba.tiefensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.breitensuche(x -> (x >= 330 && x < 340)); + assertNotNull(e); + assertEquals(334, e.intValue()); + e = ba.tiefensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.breitensuche(x -> (x >= 850 && x < 860)); + assertNotNull(e); + assertEquals(854, e.intValue()); + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(554, e.intValue()); + e = ba.tiefensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(420, e.intValue()); + e = ba.breitensuche(x -> (x >= 420 && x < 430)); + assertNotNull(e); + assertEquals(420, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(266, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(266, e.intValue()); + e = ba.tiefensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.breitensuche(x -> (x >= 480 && x < 490)); + assertNotNull(e); + assertEquals(488, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.tiefensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.breitensuche(x -> (x >= 900 && x < 910))); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(817, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(819, e.intValue()); + e = ba.tiefensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.breitensuche(x -> (x >= 800 && x < 810)); + assertNotNull(e); + assertEquals(808, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(726, e.intValue()); + e = ba.tiefensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.breitensuche(x -> (x >= 490 && x < 500)); + assertNotNull(e); + assertEquals(492, e.intValue()); + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(438, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(412, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(414, e.intValue()); + e = ba.tiefensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(99, e.intValue()); + e = ba.breitensuche(x -> (x >= 90 && x < 100)); + assertNotNull(e); + assertEquals(92, e.intValue()); + e = ba.tiefensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(770, e.intValue()); + e = ba.breitensuche(x -> (x >= 770 && x < 780)); + assertNotNull(e); + assertEquals(773, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(21, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(27, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(80, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(388, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(651, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(650, e.intValue()); + } + + @Test + public void testEnthaelt093() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(92)); + Integer e; + assertNull(ba.tiefensuche(x -> (x >= 910 && x < 920))); + assertNull(ba.breitensuche(x -> (x >= 910 && x < 920))); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(536, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(396, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(396, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(518, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.breitensuche(x -> (x >= 750 && x < 760))); + assertNull(ba.tiefensuche(x -> (x >= 170 && x < 180))); + assertNull(ba.breitensuche(x -> (x >= 170 && x < 180))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(575, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(574, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 840 && x < 850))); + assertNull(ba.breitensuche(x -> (x >= 840 && x < 850))); + e = ba.tiefensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.breitensuche(x -> (x >= 190 && x < 200)); + assertNotNull(e); + assertEquals(191, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(256, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(257, e.intValue()); + e = ba.tiefensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(104, e.intValue()); + e = ba.breitensuche(x -> (x >= 100 && x < 110)); + assertNotNull(e); + assertEquals(102, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(144, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(166, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(593, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(596, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(764, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(947, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(942, e.intValue()); + e = ba.tiefensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.breitensuche(x -> (x >= 660 && x < 670)); + assertNotNull(e); + assertEquals(665, e.intValue()); + e = ba.tiefensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.breitensuche(x -> (x >= 690 && x < 700)); + assertNotNull(e); + assertEquals(691, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(954, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(959, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(903, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(33, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(39, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(115, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(119, e.intValue()); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(938, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(935, e.intValue()); + } + + @Test + public void testEnthaelt094() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(93)); + Integer e; + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(708, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(705, e.intValue()); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(406, e.intValue()); + e = ba.tiefensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.breitensuche(x -> (x >= 500 && x < 510)); + assertNotNull(e); + assertEquals(501, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(849, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(658, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 960 && x < 970))); + assertNull(ba.breitensuche(x -> (x >= 960 && x < 970))); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(323, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(323, e.intValue()); + e = ba.tiefensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.breitensuche(x -> (x >= 40 && x < 50)); + assertNotNull(e); + assertEquals(43, e.intValue()); + e = ba.tiefensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(270, e.intValue()); + e = ba.breitensuche(x -> (x >= 270 && x < 280)); + assertNotNull(e); + assertEquals(270, e.intValue()); + e = ba.tiefensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(816, e.intValue()); + e = ba.breitensuche(x -> (x >= 810 && x < 820)); + assertNotNull(e); + assertEquals(813, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 470 && x < 480))); + assertNull(ba.breitensuche(x -> (x >= 470 && x < 480))); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(737, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(363, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(363, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 430 && x < 440))); + assertNull(ba.breitensuche(x -> (x >= 430 && x < 440))); + e = ba.tiefensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + e = ba.breitensuche(x -> (x >= 930 && x < 940)); + assertNotNull(e); + assertEquals(936, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 560 && x < 570))); + assertNull(ba.breitensuche(x -> (x >= 560 && x < 570))); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(154, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(155, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(726, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(874, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(916, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(912, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(687, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(684, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(113, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(111, e.intValue()); + e = ba.tiefensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(374, e.intValue()); + e = ba.breitensuche(x -> (x >= 370 && x < 380)); + assertNotNull(e); + assertEquals(375, e.intValue()); + } + + @Test + public void testEnthaelt095() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(94)); + Integer e; + e = ba.tiefensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(430, e.intValue()); + e = ba.breitensuche(x -> (x >= 430 && x < 440)); + assertNotNull(e); + assertEquals(437, e.intValue()); + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(16, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(18, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(883, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(881, e.intValue()); + e = ba.tiefensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.breitensuche(x -> (x >= 80 && x < 90)); + assertNotNull(e); + assertEquals(82, e.intValue()); + e = ba.tiefensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.breitensuche(x -> (x >= 620 && x < 630)); + assertNotNull(e); + assertEquals(620, e.intValue()); + e = ba.tiefensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(951, e.intValue()); + e = ba.breitensuche(x -> (x >= 950 && x < 960)); + assertNotNull(e); + assertEquals(955, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(638, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(899, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(988, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(985, e.intValue()); + e = ba.tiefensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.breitensuche(x -> (x >= 20 && x < 30)); + assertNotNull(e); + assertEquals(26, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(732, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(151, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(312, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(251, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(251, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(268, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(262, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(657, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(654, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(207, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.tiefensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + e = ba.breitensuche(x -> (x >= 670 && x < 680)); + assertNotNull(e); + assertEquals(678, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.tiefensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.breitensuche(x -> (x >= 110 && x < 120))); + assertNull(ba.tiefensuche(x -> (x >= 810 && x < 820))); + assertNull(ba.breitensuche(x -> (x >= 810 && x < 820))); + } + + @Test + public void testEnthaelt096() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(95)); + Integer e; + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(927, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(927, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(865, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(865, e.intValue()); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 120 && x < 130))); + assertNull(ba.breitensuche(x -> (x >= 120 && x < 130))); + e = ba.tiefensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.breitensuche(x -> (x >= 570 && x < 580)); + assertNotNull(e); + assertEquals(576, e.intValue()); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(717, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(734, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(739, e.intValue()); + e = ba.tiefensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + e = ba.breitensuche(x -> (x >= 880 && x < 890)); + assertNotNull(e); + assertEquals(887, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 300 && x < 310))); + assertNull(ba.breitensuche(x -> (x >= 300 && x < 310))); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(722, e.intValue()); + e = ba.tiefensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + e = ba.breitensuche(x -> (x >= 650 && x < 660)); + assertNotNull(e); + assertEquals(655, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 950 && x < 960))); + assertNull(ba.breitensuche(x -> (x >= 950 && x < 960))); + e = ba.tiefensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.breitensuche(x -> (x >= 240 && x < 250)); + assertNotNull(e); + assertEquals(243, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(209, e.intValue()); + e = ba.tiefensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(680, e.intValue()); + e = ba.breitensuche(x -> (x >= 680 && x < 690)); + assertNotNull(e); + assertEquals(685, e.intValue()); + e = ba.tiefensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(61, e.intValue()); + e = ba.breitensuche(x -> (x >= 60 && x < 70)); + assertNotNull(e); + assertEquals(63, e.intValue()); + e = ba.tiefensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(256, e.intValue()); + e = ba.breitensuche(x -> (x >= 250 && x < 260)); + assertNotNull(e); + assertEquals(253, e.intValue()); + e = ba.tiefensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(537, e.intValue()); + e = ba.breitensuche(x -> (x >= 530 && x < 540)); + assertNotNull(e); + assertEquals(530, e.intValue()); + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(470, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(474, e.intValue()); + } + + @Test + public void testEnthaelt097() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(96)); + Integer e; + e = ba.tiefensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + e = ba.breitensuche(x -> (x >= 470 && x < 480)); + assertNotNull(e); + assertEquals(471, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(963, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.tiefensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(910, e.intValue()); + e = ba.breitensuche(x -> (x >= 910 && x < 920)); + assertNotNull(e); + assertEquals(918, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.breitensuche(x -> (x >= 250 && x < 260))); + assertNull(ba.tiefensuche(x -> (x >= 390 && x < 400))); + assertNull(ba.breitensuche(x -> (x >= 390 && x < 400))); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(401, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(127, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(983, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(982, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.breitensuche(x -> (x >= 460 && x < 470)); + assertNotNull(e); + assertEquals(463, e.intValue()); + e = ba.tiefensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(261, e.intValue()); + e = ba.breitensuche(x -> (x >= 260 && x < 270)); + assertNotNull(e); + assertEquals(261, e.intValue()); + e = ba.tiefensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.breitensuche(x -> (x >= 110 && x < 120)); + assertNotNull(e); + assertEquals(110, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(736, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(725, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(723, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.breitensuche(x -> (x >= 490 && x < 500))); + assertNull(ba.tiefensuche(x -> (x >= 890 && x < 900))); + assertNull(ba.breitensuche(x -> (x >= 890 && x < 900))); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(365, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(364, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(158, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.tiefensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(708, e.intValue()); + e = ba.breitensuche(x -> (x >= 700 && x < 710)); + assertNotNull(e); + assertEquals(702, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(160, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(162, e.intValue()); + e = ba.tiefensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(347, e.intValue()); + e = ba.breitensuche(x -> (x >= 340 && x < 350)); + assertNotNull(e); + assertEquals(341, e.intValue()); + e = ba.tiefensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(282, e.intValue()); + e = ba.breitensuche(x -> (x >= 280 && x < 290)); + assertNotNull(e); + assertEquals(285, e.intValue()); + e = ba.tiefensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(877, e.intValue()); + e = ba.breitensuche(x -> (x >= 870 && x < 880)); + assertNotNull(e); + assertEquals(870, e.intValue()); + } + + @Test + public void testEnthaelt098() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(97)); + Integer e; + e = ba.tiefensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(555, e.intValue()); + e = ba.breitensuche(x -> (x >= 550 && x < 560)); + assertNotNull(e); + assertEquals(555, e.intValue()); + e = ba.tiefensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + e = ba.breitensuche(x -> (x >= 50 && x < 60)); + assertNotNull(e); + assertEquals(57, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.breitensuche(x -> (x >= 710 && x < 720))); + assertNull(ba.tiefensuche(x -> (x >= 10 && x < 20))); + assertNull(ba.breitensuche(x -> (x >= 10 && x < 20))); + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(407, e.intValue()); + e = ba.tiefensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(895, e.intValue()); + e = ba.breitensuche(x -> (x >= 890 && x < 900)); + assertNotNull(e); + assertEquals(895, e.intValue()); + e = ba.tiefensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.breitensuche(x -> (x >= 310 && x < 320)); + assertNotNull(e); + assertEquals(316, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(380, e.intValue()); + e = ba.tiefensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.breitensuche(x -> (x >= 780 && x < 790)); + assertNotNull(e); + assertEquals(786, e.intValue()); + e = ba.tiefensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(542, e.intValue()); + e = ba.breitensuche(x -> (x >= 540 && x < 550)); + assertNotNull(e); + assertEquals(541, e.intValue()); + e = ba.tiefensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(981, e.intValue()); + e = ba.breitensuche(x -> (x >= 980 && x < 990)); + assertNotNull(e); + assertEquals(986, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(592, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(594, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(512, e.intValue()); + e = ba.tiefensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(611, e.intValue()); + e = ba.breitensuche(x -> (x >= 610 && x < 620)); + assertNotNull(e); + assertEquals(611, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.breitensuche(x -> (x >= 130 && x < 140))); + assertNull(ba.tiefensuche(x -> (x >= 720 && x < 730))); + assertNull(ba.breitensuche(x -> (x >= 720 && x < 730))); + e = ba.tiefensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.breitensuche(x -> (x >= 940 && x < 950)); + assertNotNull(e); + assertEquals(945, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(34, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(36, e.intValue()); + e = ba.tiefensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(637, e.intValue()); + e = ba.breitensuche(x -> (x >= 630 && x < 640)); + assertNotNull(e); + assertEquals(633, e.intValue()); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(150, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(153, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(763, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(837, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(201, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(203, e.intValue()); + e = ba.tiefensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(456, e.intValue()); + e = ba.breitensuche(x -> (x >= 450 && x < 460)); + assertNotNull(e); + assertEquals(453, e.intValue()); + } + + @Test + public void testEnthaelt099() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(98)); + Integer e; + e = ba.tiefensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + e = ba.breitensuche(x -> (x >= 10 && x < 20)); + assertNotNull(e); + assertEquals(17, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 440 && x < 450))); + assertNull(ba.breitensuche(x -> (x >= 440 && x < 450))); + e = ba.tiefensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + e = ba.breitensuche(x -> (x >= 150 && x < 160)); + assertNotNull(e); + assertEquals(156, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 530 && x < 540))); + assertNull(ba.breitensuche(x -> (x >= 530 && x < 540))); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(842, e.intValue()); + e = ba.tiefensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(966, e.intValue()); + e = ba.breitensuche(x -> (x >= 960 && x < 970)); + assertNotNull(e); + assertEquals(968, e.intValue()); + e = ba.tiefensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.breitensuche(x -> (x >= 380 && x < 390)); + assertNotNull(e); + assertEquals(381, e.intValue()); + e = ba.tiefensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(200, e.intValue()); + e = ba.breitensuche(x -> (x >= 200 && x < 210)); + assertNotNull(e); + assertEquals(207, e.intValue()); + e = ba.tiefensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.breitensuche(x -> (x >= 220 && x < 230)); + assertNotNull(e); + assertEquals(229, e.intValue()); + e = ba.tiefensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + e = ba.breitensuche(x -> (x >= 140 && x < 150)); + assertNotNull(e); + assertEquals(147, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.breitensuche(x -> (x >= 600 && x < 610))); + assertNull(ba.tiefensuche(x -> (x >= 930 && x < 940))); + assertNull(ba.breitensuche(x -> (x >= 930 && x < 940))); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(327, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(640, e.intValue()); + e = ba.tiefensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.breitensuche(x -> (x >= 730 && x < 740)); + assertNotNull(e); + assertEquals(738, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(514, e.intValue()); + e = ba.tiefensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(970, e.intValue()); + e = ba.breitensuche(x -> (x >= 970 && x < 980)); + assertNotNull(e); + assertEquals(970, e.intValue()); + e = ba.tiefensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(769, e.intValue()); + e = ba.breitensuche(x -> (x >= 760 && x < 770)); + assertNotNull(e); + assertEquals(767, e.intValue()); + e = ba.tiefensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(30, e.intValue()); + e = ba.breitensuche(x -> (x >= 30 && x < 40)); + assertNotNull(e); + assertEquals(37, e.intValue()); + e = ba.tiefensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(927, e.intValue()); + e = ba.breitensuche(x -> (x >= 920 && x < 930)); + assertNotNull(e); + assertEquals(929, e.intValue()); + e = ba.tiefensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(728, e.intValue()); + e = ba.breitensuche(x -> (x >= 720 && x < 730)); + assertNotNull(e); + assertEquals(721, e.intValue()); + e = ba.tiefensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(868, e.intValue()); + e = ba.breitensuche(x -> (x >= 860 && x < 870)); + assertNotNull(e); + assertEquals(862, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(568, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(566, e.intValue()); + e = ba.tiefensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(905, e.intValue()); + e = ba.breitensuche(x -> (x >= 900 && x < 910)); + assertNotNull(e); + assertEquals(907, e.intValue()); + } + + @Test + public void testEnthaelt100() + { + Baumalgorithmen2 ba = new Baumalgorithmen2(Testbaeume.getTestBaum(99)); + Integer e; + e = ba.tiefensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.breitensuche(x -> (x >= 400 && x < 410)); + assertNotNull(e); + assertEquals(402, e.intValue()); + e = ba.tiefensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + e = ba.breitensuche(x -> (x >= 160 && x < 170)); + assertNotNull(e); + assertEquals(164, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 270 && x < 280))); + assertNull(ba.breitensuche(x -> (x >= 270 && x < 280))); + e = ba.tiefensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.breitensuche(x -> (x >= 710 && x < 720)); + assertNotNull(e); + assertEquals(711, e.intValue()); + e = ba.tiefensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(752, e.intValue()); + e = ba.breitensuche(x -> (x >= 750 && x < 760)); + assertNotNull(e); + assertEquals(750, e.intValue()); + e = ba.tiefensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.breitensuche(x -> (x >= 640 && x < 650)); + assertNotNull(e); + assertEquals(643, e.intValue()); + e = ba.tiefensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.breitensuche(x -> (x >= 830 && x < 840)); + assertNotNull(e); + assertEquals(830, e.intValue()); + e = ba.tiefensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + e = ba.breitensuche(x -> (x >= 560 && x < 570)); + assertNotNull(e); + assertEquals(564, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 450 && x < 460))); + assertNull(ba.breitensuche(x -> (x >= 450 && x < 460))); + e = ba.tiefensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + e = ba.breitensuche(x -> (x >= 790 && x < 800)); + assertNotNull(e); + assertEquals(798, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 970 && x < 980))); + assertNull(ba.breitensuche(x -> (x >= 970 && x < 980))); + e = ba.tiefensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.breitensuche(x -> (x >= 320 && x < 330)); + assertNotNull(e); + assertEquals(328, e.intValue()); + e = ba.tiefensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.breitensuche(x -> (x >= 590 && x < 600)); + assertNotNull(e); + assertEquals(595, e.intValue()); + e = ba.tiefensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.breitensuche(x -> (x >= 360 && x < 370)); + assertNotNull(e); + assertEquals(366, e.intValue()); + e = ba.tiefensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(417, e.intValue()); + e = ba.breitensuche(x -> (x >= 410 && x < 420)); + assertNotNull(e); + assertEquals(411, e.intValue()); + e = ba.tiefensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(601, e.intValue()); + e = ba.breitensuche(x -> (x >= 600 && x < 610)); + assertNotNull(e); + assertEquals(603, e.intValue()); + assertNull(ba.tiefensuche(x -> (x >= 660 && x < 670))); + assertNull(ba.breitensuche(x -> (x >= 660 && x < 670))); + e = ba.tiefensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(351, e.intValue()); + e = ba.breitensuche(x -> (x >= 350 && x < 360)); + assertNotNull(e); + assertEquals(350, e.intValue()); + e = ba.tiefensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(846, e.intValue()); + e = ba.breitensuche(x -> (x >= 840 && x < 850)); + assertNotNull(e); + assertEquals(840, e.intValue()); + e = ba.tiefensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(392, e.intValue()); + e = ba.breitensuche(x -> (x >= 390 && x < 400)); + assertNotNull(e); + assertEquals(396, e.intValue()); + e = ba.tiefensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(510, e.intValue()); + e = ba.breitensuche(x -> (x >= 510 && x < 520)); + assertNotNull(e); + assertEquals(513, e.intValue()); + e = ba.tiefensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(121, e.intValue()); + e = ba.breitensuche(x -> (x >= 120 && x < 130)); + assertNotNull(e); + assertEquals(122, e.intValue()); + e = ba.tiefensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(231, e.intValue()); + e = ba.breitensuche(x -> (x >= 230 && x < 240)); + assertNotNull(e); + assertEquals(230, e.intValue()); + e = ba.tiefensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(5, e.intValue()); + e = ba.breitensuche(x -> (x >= 0 && x < 10)); + assertNotNull(e); + assertEquals(1, e.intValue()); + } + +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Baumalgorithmen.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Baumalgorithmen.java new file mode 100644 index 0000000..896223e --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Baumalgorithmen.java @@ -0,0 +1,130 @@ + +/** + * Führt verschiedene Algorithmen auf Binärbäumen aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Baumalgorithmen +{ + /** + * Die Wurzel des Baums, mit dem der Algorithmus durchgeführt werden soll + */ + protected Binaerbaum wurzel; + + /** + * Erzeugt ein neues Algorithmen-Objekt + * @param wurzel Die Wurzel des Baums, der verarbeitet werden soll + */ + public Baumalgorithmen(Binaerbaum wurzel) + { + this.wurzel = wurzel; + } + + /** + * Zeigt den Baum auf der Konsole an. + */ + public void baumAnzeigen() + { + if (wurzel != null) + { + System.out.println(wurzel.daten); + baumAnzeigen(wurzel.links, "", true); + baumAnzeigen(wurzel.rechts, "", false); + } + } + + private void baumAnzeigen(Binaerbaum b, String indent, boolean left) + { + System.out.print(indent); + System.out.print(left ? "\u251C " : "\u2514 "); + if (b != null) + { + System.out.println(b.daten); + if (b.links != null || b.rechts != null) + { + indent += (left ? "\u2502 " : " "); + baumAnzeigen(b.links, indent, true); + baumAnzeigen(b.rechts, indent, false); + } + } + else + { + System.out.println(""); + } + } + + /** + * Gibt die Tiefe des Baums zurück + * @return Die Tiefe des Baums, gezählt ab der Wurzel + */ + public int tiefe() + { + return tiefe(wurzel); + } + + /** + * Gibt die Tiefe eines Baums zurück + * @param b Der Baum, dessen Tiefe bestimmt werden soll + * @return Die Tiefe des Baums, gezählt ab b + */ + private int tiefe(Binaerbaum b) + { + if (b == null) + { + return 0; + } + return 1 + Math.max(tiefe(b.links), tiefe(b.rechts)); + } + + /** + * Gibt die Anzahl der Knoten im Baums zurück + * @return Die Anzahl aller Knoten im Baum + */ + public int anzahl() + { + return anzahl(wurzel); + } + + /** + * Gibt die Anzahl der Knoten in einem Baums zurück + * @param b Der Baum, in dem die Knoten gezählt werden sollen + * @return Die Anzahl der Knoten, die sich von b an im Baum befinden (inklusive b) + */ + private int anzahl(Binaerbaum b) + { + if (b == null) + { + return 0; + } + return 1 + anzahl(b.links) + anzahl(b.rechts); + } + + /** + * Prüft, ob sich ein Wert im Baum befindet + * @param wert Der zu suchende Wert + * @return true, wenn ein Knoten den Wert enthält; false sonst + */ + public boolean enthaelt(T wert) + { + return enthaelt(wurzel, wert); + } + + /** + * Prüft, ob sich ein Wert in b oder darunter befindet + * @param b Der Baum, in dem der Wert gesucht werden soll + * @return true, wenn b oder einer seiner Kindknoten den Wert enthält; false sonst + */ + private boolean enthaelt(Binaerbaum b, T wert) + { + if (b == null) + { + return false; + } + if (b.daten.equals(wert)) + { + return true; + } + return enthaelt(b.links, wert) || enthaelt(b.rechts, wert); + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Baumalgorithmen2.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Baumalgorithmen2.java new file mode 100644 index 0000000..529ba3d --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Baumalgorithmen2.java @@ -0,0 +1,47 @@ +import java.util.function.Predicate; + +/** + * Tiefen- und Breitensuche + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Baumalgorithmen2 extends Baumalgorithmen +{ + public Baumalgorithmen2(Binaerbaum wurzel) + { + super(wurzel); + } + + public Integer breitensuche(Predicate p) + { + return suche(p, new ArrayQueue>()); + } + + public Integer tiefensuche(Predicate p) + { + return suche(p, new ArrayStack>()); + } + + public Integer suche(Predicate p, Container> todo) + { + todo.insert(wurzel); + while(!todo.isEmpty()) + { + Binaerbaum tmp = todo.removeNext(); + if (p.test(tmp.daten)) + { + return tmp.daten; + } + if (tmp.rechts != null) + { + todo.insert(tmp.rechts); + } + if (tmp.links != null) + { + todo.insert(tmp.links); + } + } + return null; + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Binaerbaum.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Binaerbaum.java new file mode 100644 index 0000000..2f05bbc --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Binaerbaum.java @@ -0,0 +1,63 @@ + +/** + * Ein Knoten eines Binärbaums + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Binaerbaum +{ + /** + * Der Datenwert des Knotens + */ + public T daten; + + /** + * Der linke Kindbaum + */ + public Binaerbaum links; + + /** + * Der rechte Kindbaum + */ + public Binaerbaum rechts; + + /** + * Erzeugt einen Blattknoten mit leerem Datenwert + */ + public Binaerbaum() + { + this(null, null, null); + } + + /** + * Erzeugt einen Knoten mit Datenwert und Kindern + * @param daten Der Datenwert + * @param links Der linke Kindbaum + * @param rechts Der rechte Kindbaum + */ + public Binaerbaum(T daten, Binaerbaum links, Binaerbaum rechts) + { + this.daten = daten; + this.links = links; + this.rechts = rechts; + } + + /** + * Erzeugt einen Blattknoten mit Datenwert + * @param daten Der Datenwert + */ + public Binaerbaum(T daten) + { + this(daten, null, null); + } + + /** + * Gibt zurück, ob der Knoten ein Blatt ist + * @return true, wenn der Knoten ein Blatt ist; false sonst + */ + public boolean istBlatt() + { + return links == null && rechts == null; + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Container.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Container.java new file mode 100644 index 0000000..4c013ca --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Container.java @@ -0,0 +1,32 @@ +/** + * Abstrakte Oberklasse für Queue und Stack + * + * @author Rainer Helfrich + * @version November 2020 + */ +public abstract class Container +{ + /** + * Gibt zurück, ob der Container leer ist + * @return true, wenn der Container leer ist; false sonst + */ + public abstract boolean isEmpty(); + + /** + * Fügt ein neues Element in den Container ein + * @param x Das neue Element + */ + public abstract void insert(T x); + + /** + * Entfernt das nächste Element aus dem Container (falls er nicht leer ist) und gibt es zurück + * @return Das bisherige "nächste" Element + */ + public abstract T removeNext(); + + /** + * Gibt das nächste Element des Containers zurück (falls er nicht leer ist) + * @return Das "nächste" Element + */ + public abstract T getNext(); +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Queue.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Queue.java new file mode 100644 index 0000000..2b6352a --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Queue.java @@ -0,0 +1,59 @@ +/** + * Abstrakte Basisklasse für Queues + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Queue extends Container +{ + /** + * Fügt ein neues Element hinten in der Schlange ein + * @param x Das neue Element + */ + public abstract void enqueue(T x); + + /** + * Entfernt das vorderste Element aus der Queue (falls sie nicht leer ist) und gibt es zurück + * @return Das bisherige vorderste Element + */ + public abstract T dequeue(); + + /** + * Gibt das vorderste Element der Queue zurück (falls sie nicht leer ist) + * @return Das vorderste Element + */ + public abstract T front(); + + /** + * Fügt ein neues Element in den Container ein + * Entspricht hier dem enqueue + * @param x Das neue Element + */ + @Override + public void insert(T x) + { + enqueue(x); + } + + /** + * Entfernt das nächste Element aus dem Container (falls er nicht leer ist) und gibt es zurück + * Entspricht hier dem dequeue + * @return Das bisherige "nächste" Element + */ + @Override + public T removeNext() + { + return dequeue(); + } + + /** + * Gibt das nächste Element des Containers zurück (falls er nicht leer ist) + * Entspricht hier dem front + * @return Das "nächste" Element + */ + @Override + public T getNext() + { + return front(); + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/README.TXT b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/README.TXT new file mode 100644 index 0000000..e3c8ef1 Binary files /dev/null and b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/README.TXT differ diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Stack.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Stack.java new file mode 100644 index 0000000..2998943 --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Stack.java @@ -0,0 +1,59 @@ +/** + * Abstrakte Basisklasse für Stacks + * + * @author Rainer Helfrich + * @version November 2020 + */ +public abstract class Stack extends Container +{ + /** + * Legt ein neues Element auf den Stack + * @param x Das neue Element + */ + public abstract void push(T x); + + /** + * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück + * @return Das bisherige oberste Element + */ + public abstract T pop(); + + /** + * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist) + * @return Das oberste Element + */ + public abstract T top(); + + /** + * Fügt ein neues Element in den Container ein + * Entspricht hier dem push + * @param x Das neue Element + */ + @Override + public void insert(T x) + { + push(x); + } + + /** + * Entfernt das nächste Element aus dem Container (falls er nicht leer ist) und gibt es zurück + * Entspricht hier dem pop + * @return Das bisherige "nächste" Element + */ + @Override + public T removeNext() + { + return pop(); + } + + /** + * Gibt das nächste Element des Containers zurück (falls er nicht leer ist) + * Entspricht hier dem top + * @return Das "nächste" Element + */ + @Override + public T getNext() + { + return top(); + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Testbaeume.java b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Testbaeume.java new file mode 100644 index 0000000..a7f9076 --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/Testbaeume.java @@ -0,0 +1,75 @@ +import java.util.ArrayList; +import java.io.FileReader; +import java.io.BufferedReader; +import java.util.ArrayList; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Liest Testbäume aus einer Datei aus + * + * @author Rainer Helfrich + * @version November 2020 + */ +public class Testbaeume +{ + /** + * Die aus der Datei eingelesenen Bäume + */ + static ArrayList> baeume; + + private static void readFile() + { + try + { + FileReader fileReader = new FileReader("testfaelle.txt"); + BufferedReader bufferedReader = new BufferedReader(fileReader); + baeume = new ArrayList>(); + String line = null; + while ((line = bufferedReader.readLine()) != null) { + AtomicInteger ai = new AtomicInteger(0); + Binaerbaum b = parse(line.toCharArray(), ai); + baeume.add(b); + } + bufferedReader.close(); + } + catch(Exception x) + { + System.out.println(x.getMessage()); + baeume = null; + } + } + + private static Binaerbaum parse(char[] c, AtomicInteger s) + { + int anfang = s.incrementAndGet(); + while(c[s.get()] != '(' && c[s.get()] != ')') + { + s.incrementAndGet(); + } + String tmp = new String(c, anfang, s.get()-anfang); + int value = Integer.parseInt(tmp); + Binaerbaum ergebnis = new Binaerbaum(value); + if (c[s.get()] == '(') + { + ergebnis.links = parse(c, s); + s.incrementAndGet(); + ergebnis.rechts = parse(c, s); + s.incrementAndGet(); + } + return ergebnis; + } + + /** + * Gibt einen der Testbäume aus der Datei zurück + * @param nummer Die Nummer des Baums + * @return Den gewünschten Baum, wenn die Nummer gültig ist; null sonst + */ + public static Binaerbaum getTestBaum(int nummer) + { + if (baeume == null) + readFile(); + if (nummer >= 0 && nummer < baeume.size()) + return baeume.get(nummer); + return null; + } +} diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/package.bluej b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/package.bluej new file mode 100644 index 0000000..d1475c6 --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/package.bluej @@ -0,0 +1,135 @@ +#BlueJ package file +dependency1.from=Baumalgorithmen +dependency1.to=Binaerbaum +dependency1.type=UsesDependency +dependency10.from=Baumalgorithmen2 +dependency10.to=Container +dependency10.type=UsesDependency +dependency11.from=Testbaeume +dependency11.to=Binaerbaum +dependency11.type=UsesDependency +dependency2.from=BaumTester +dependency2.to=Baumalgorithmen +dependency2.type=UsesDependency +dependency3.from=BaumTester +dependency3.to=Binaerbaum +dependency3.type=UsesDependency +dependency4.from=BaumTester +dependency4.to=Testbaeume +dependency4.type=UsesDependency +dependency5.from=BaumTester2 +dependency5.to=Baumalgorithmen2 +dependency5.type=UsesDependency +dependency6.from=BaumTester2 +dependency6.to=Testbaeume +dependency6.type=UsesDependency +dependency7.from=Baumalgorithmen2 +dependency7.to=Binaerbaum +dependency7.type=UsesDependency +dependency8.from=Baumalgorithmen2 +dependency8.to=ArrayQueue +dependency8.type=UsesDependency +dependency9.from=Baumalgorithmen2 +dependency9.to=ArrayStack +dependency9.type=UsesDependency +editor.fx.0.height=739 +editor.fx.0.width=1465 +editor.fx.0.x=427 +editor.fx.0.y=163 +objectbench.height=138 +objectbench.width=1896 +package.divider.horizontal=0.6 +package.divider.vertical=0.8483263598326359 +package.editor.height=804 +package.editor.width=1785 +package.editor.x=719 +package.editor.y=22 +package.frame.height=1056 +package.frame.width=1936 +package.numDependencies=11 +package.numTargets=11 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=ArrayQueue +target1.showInterface=false +target1.type=ClassTarget +target1.width=130 +target1.x=80 +target1.y=550 +target10.height=50 +target10.name=Testbaeume +target10.showInterface=false +target10.type=ClassTarget +target10.width=100 +target10.x=79 +target10.y=264 +target11.height=50 +target11.name=Stack +target11.showInterface=false +target11.type=AbstractTarget +target11.width=80 +target11.x=220 +target11.y=450 +target2.height=50 +target2.name=Binaerbaum +target2.showInterface=false +target2.type=ClassTarget +target2.width=130 +target2.x=170 +target2.y=60 +target3.height=50 +target3.name=Container +target3.showInterface=false +target3.type=AbstractTarget +target3.width=110 +target3.x=150 +target3.y=340 +target4.height=50 +target4.name=Baumalgorithmen +target4.showInterface=false +target4.type=ClassTarget +target4.width=160 +target4.x=300 +target4.y=130 +target5.height=50 +target5.name=ArrayStack +target5.showInterface=false +target5.type=ClassTarget +target5.width=120 +target5.x=200 +target5.y=620 +target6.height=50 +target6.name=BaumTester +target6.showInterface=false +target6.type=UnitTestTargetJunit4 +target6.width=100 +target6.x=460 +target6.y=210 +target7.height=50 +target7.name=BaumTester2 +target7.showInterface=false +target7.type=UnitTestTargetJunit4 +target7.width=110 +target7.x=470 +target7.y=360 +target8.height=50 +target8.name=Baumalgorithmen2 +target8.showInterface=false +target8.type=ClassTarget +target8.width=140 +target8.x=280 +target8.y=250 +target9.height=50 +target9.name=Queue +target9.showInterface=false +target9.type=AbstractTarget +target9.width=90 +target9.x=100 +target9.y=450 diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/testfaelle.txt b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/testfaelle.txt new file mode 100644 index 0000000..7c0595c --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/02_tiefen_und_breitensuche_loes/testfaelle.txt @@ -0,0 +1,100 @@ +(366(518(665(284(101(853(360(314(190(465(386(162)(241))(459(197)(861)))(654(427(528)(255))(351(835)(533))))(445(394)(717(311)(530(253)(429)))))(756))(749(236(53(339(469(265)(695))(642(837)(192)))(860))(215))(618(340)(547(201(410)(811(37)(331)))(567)))))(130))(685(76(105(293(837)(262))(3(766)(875(161)(773(65(505)(939))(351(33)(379))))))(94))(301(90(820(166(63(931(73)(590))(936(439)(190)))(990(270(240)(807))(795)))(194(919(694)(244(430)(243)))(924)))(468(420(668)(282(73(966)(860))(270(400)(608))))(914(467)(402(915(547)(648))(96(715)(255))))))(259(870(672(733)(854(327(778)(811))(150)))(629(398(837)(333(203)(270)))(104(749(730)(534))(59(668)(940)))))(769(130)(366(408)(674)))))))(512(869(507(359(823(542)(799(713(910(693)(435))(319(663)(736)))(198)))(992))(682))(73(49)(872)))(715(628)(297))))(274(532(581(418(844)(325))(747(420(97(426(902)(991(682(440)(307))(361(493)(173))))(82(739)(645)))(493(837(182)(720(245)(817(498)(968))))(831(302)(939(429(907)(473))(914)))))(859(111(802(413(303)(291))(432(883(20)(891))(560(263)(932))))(874(85(679(130)(79))(2(761)(596)))(959(675(66)(894))(847(899)(364)))))(448))))(844(446)(690(377)(561))))(615(266)(757(612)(509(374)(641(998(367(40(223(598)(359))(129(700)(312)))(539(534(127)(583))(351(551)(108))))(276))(111(860(406(706(561)(854))(298))(680))(919))))))))(830(154(760(719(29)(9(395(471(575(625)(960(743(939)(344))(499)))(413(186(60(224)(691))(951(821)(906)))(320)))(640(555(914)(820))(910(657(725(105)(879))(896(538)(806)))(572(13(175)(254))(362(276)(664))))))(118(129(973(588)(843(20)(212(115)(2))))(300))(215(15(322)(317(144(646)(549))(411)))(50(274(452(129)(879))(454(473)(758)))(568(13(766)(542))(981(129)(211))))))))(170))(900(132(614(589(526)(550))(379(947(268(789(787(255)(889))(234))(258(112(9)(669))(593(871)(191))))(248))(451(474(35(112(436)(165))(930(550)(739)))(339(271)(745(56)(905))))(790(981)(562(33(737)(533))(648(530)(140)))))))(488))(136)))(123(832(708(637(395)(156))(360))(71(498(989(10(571)(964(248(460)(751(848)(925)))(626)))(758))(190(357(999(155)(944(210(223)(239))(687(125)(817))))(395))(593(170(119)(73(269(614)(685))(84)))(185(672)(587(80)(633))))))(198(495(107)(91(487(163(178)(628(935)(376)))(977(513)(648)))(925)))(546(595)(908(440)(557(74)(328(318(304)(292))(883(209)(198)))))))))(459(108)(358(450(817)(161))(233(503(321)(365(295)(392(811)(18(807(785)(268))(821)))))(757))))))) +(796(145(612(934(49(576)(126(436(825(199)(657))(983(245)(286)))(942(105)(545))))(42(514(577)(575(8(157)(275))(617(534)(266))))(714(783(935(907)(964))(88(376)(912)))(653(24(199)(221))(244(526)(50))))))(829(186(24(829(855(529)(692))(429(635)(202)))(932(306)(120)))(368(495)(41(566)(512(591)(478)))))(4(650(339(8(605)(714))(203(926)(92)))(480(778(367)(273))(414(4)(191))))(102(889(558(413)(379))(159(931)(866)))(514)))))(743(286(669)(277(800(656)(842))(576(680(913(429)(355))(445(51)(681)))(311))))(194)))(273(760(978(506)(240(273(592(409(521)(731))(937(463)(941)))(284))(839(932)(502(996(396)(90))(444)))))(56(620(37(872)(131(377(950)(185))(416)))(170(22(834(726)(208))(247(839)(205)))(597(103(154)(349))(810))))(109)))(886(39)(9(499(597(217)(763(530(174)(699))(257(904)(185))))(54(556(310(258)(475))(382(66)(187)))(995(958)(993(604)(14)))))(502(827)(808(131)(428(580(983)(342))(388)))))))) +(683(388(163(757)(113(798(174)(612(46(595)(66))(674(828)(41))))(837(948)(258(646(887)(334))(441(959)(15))))))(744(332(589)(551(671(661)(186(43)(947)))(681(301(229)(228))(419(887)(865)))))(207)))(954(649(258(654(185(288)(577(9)(344)))(661))(251))(435(410(565(15(469)(812))(665))(33))(917)))(770(69(985(916)(629(968)(719)))(656(628(39(481)(590))(210(705)(518)))(785(914)(995(221)(913)))))(861(435(98(150(51)(562))(343(706)(189)))(607))(219(404(741(216)(249))(423(258)(347)))(904(417(770)(210))(691(104)(997)))))))) +(163(852(819(592(619(567(235(402)(879(960)(406(195)(948))))(669(976(604(382)(740))(284))(611(837)(69(328)(239)))))(271))(870(664(295)(145(255)(36)))(876(194)(712(318(31)(915))(351)))))(475(45)(991)))(335(743(755)(441))(814(763(950(321(350)(387(947(374)(845))(38)))(849(23(344)(652(250)(120)))(988(691(304)(951))(110))))(705(909(916(751)(189))(747(450(764)(834))(394(517)(35))))(585(864)(9(673(898)(179))(76(160)(447))))))(731(392(446)(381))(540(656(864(0)(367(693)(629)))(305(0(125)(838))(535(938)(768))))(178(488(744(415)(328))(595))(422(371(6)(235))(884(7)(398)))))))))(946(361(346)(711(14(616(523(666(232(648)(755))(728))(870(901(690)(411))(864(527)(334))))(349(958)(27(805(192)(926))(986))))(311))(105(73(250)(466))(829(43(210(547(955)(206))(842(637)(520)))(690(984(704)(385))(715)))(277)))))(192(118)(909(177)(488(363(453(752(711(252)(343))(616(279)(315)))(62(250(718)(464))(853)))(280))(86(183(905)(319))(545(502(153(524)(28))(234(654)(538)))(207(202(196)(925))(751(611)(540)))))))))) +(428(369(333(668(626(728(715(766(113)(716))(358(119)(581)))(792(313(214)(593))(205)))(32(858(988(487)(810))(621(586)(659)))(252(958(882)(514))(464(532)(840)))))(290(185(646(134(972)(477))(24(20)(865)))(399))(639(98(814)(127))(285))))(598(719)(631(631(694(304(356)(372))(964))(295(295(351)(625))(950(934)(653))))(471))))(956(283)(918(849(594(297(774(27)(354))(217(657)(825)))(77(634(185)(308))(111(4)(151))))(944(344)(375(186(396)(331))(177(727)(9)))))(133))))(99(272(200(740(632)(544(484)(958(464(67)(779))(948(915)(280)))))(477(421(114)(232))(67(277)(374))))(481))(441(952)(513(805(383)(271(610(991(943)(145))(439))(614(404(885)(884))(854))))(55))))) +(954(577(3(685(175(779)(365))(287(144)(836(706(119(312)(761))(557(73)(706)))(131(270(116)(381))(780)))))(216))(325(688(803(795(820)(525(572(4)(406))(757(601)(139))))(398))(528(589(176)(624(174(924)(770))(665)))(175(131)(373(254(835)(548))(110)))))(695(329(432)(136(60(100(202)(814))(507(520)(797)))(760(51)(834(867)(706)))))(568))))(734(449(453(865(372(14(423(909)(290))(489(357)(387)))(769))(131(165(83(3)(125))(62(892)(339)))(984(948(401)(423))(211(174)(525)))))(881))(491(850(4)(984(661)(297(312(741)(482))(326))))(141(768(319)(362(514)(961(78)(74))))(429(163(214(626)(417))(955(995)(411)))(774(262(570)(615))(701(753)(589)))))))(429(438(800(925)(168(983(992(905)(385))(362))(985)))(787))(675(764)(437(426(113)(38(884(13)(940))(752(625)(850))))(754(404)(45(677)(371)))))))) +(606(112(79(954)(960(122(347)(738(153(282(599)(182(702)(486)))(625(947(281)(667))(908(737)(30))))(547(894(892(645)(443))(909(3)(250)))(382(510(87)(553))(527(891)(916))))))(513(122(687(590(644)(378(496)(371)))(384(990(33)(526))(245(28)(810))))(466))(867))))(368(44(945)(632))(609(491(319(623(672)(43(292(275)(338))(40(268)(814))))(227))(936))(438))))(230(982(227)(924))(472(274(834(642)(916(266)(910)))(39))(379(505(863(557(492(353(564)(821))(33))(903(916(976)(447))(866)))(181(461(472)(769))(471)))(831(557(779)(836))(791(595(552)(443))(424))))(409(157(449(833(371(734)(276))(253(14)(773)))(981(853(792)(647))(0)))(999(660(110)(106(904)(231)))(178(126(941)(259))(369))))(69(263(565(454(473)(83))(828(438)(494)))(249(889(822)(405))(732(470)(264))))(453(200(341)(829(952)(810)))(381(78)(822(640)(995)))))))))) +(911(409(461(415)(644(343(732(308)(141))(219))(897(809(70)(642(978(138(879(224)(511(639)(526)))(744(799(189)(993))(976(946)(792))))(723(388)(125(744)(850))))(427(56(117(402)(708(547)(664)))(179(572(615)(248))(13(590)(296))))(645(413(742(584)(789))(208(771)(254)))(601(84(191)(813))(955(871)(166)))))))(313))))(599(187)(279)))(988(300(428(234(90(964(998)(707))(383(586(754(413(130)(204))(204))(439(53)(481(369(761)(90))(790(7)(27)))))(797(651(371)(490(543(735)(681))(298)))(982))))(848(301)(195)))(320))(178(776(474(407(794)(926(766(991(543(883)(3))(452(725)(134)))(14(79)(254(189)(389))))(479(847(752(427)(229))(131(866)(13)))(56))))(159(760(980(696)(107(54)(624(247)(944))))(6(637)(641)))(699)))(993(188(93(854(51)(217(980(791)(542))(501)))(143(398(439(871)(102))(615(983)(268)))(651(17)(754))))(784(781(482(163)(568(233)(416)))(392(982(892)(797))(377(648)(516))))(920(691(654(685)(75))(539))(134(47)(334(398)(829))))))(829(174(509(692(882)(18(581)(772)))(68))(699(836(792)(243))(558(831)(935(435)(193)))))(712))))(42(677(447(116(976(326)(840(354)(300(677)(729))))(736(383(184(317)(823))(408(89)(806)))(175(556)(922))))(875(196(931)(848(286(175)(274))(428(625)(905))))(103(661(574(713)(900))(394(562)(583)))(915))))(84(940(153)(482))(561(775(890(539(164)(416))(290(763)(984)))(5))(888))))(270(52(788(412(179)(201(388)(480(585)(231))))(259(463)(542(918)(412(453)(615)))))(313))(139)))))(389(964(60(636)(456(688(33)(293(946)(310(872(915(749)(657))(544(40)(984)))(851(557(258)(322))(271(63)(619))))))(632(64(959(615(501)(760(716)(853)))(666(360(427)(5))(566(120)(108))))(234(7(834)(320(781)(838)))(169(144(798)(625))(129(969)(647)))))(154))))(378(99)(287(198(565(105(960(865(851)(354))(342))(638(742(229)(493))(731)))(165(331(317(449)(192))(838))(421(585(669)(552))(233(938)(966)))))(630))(937))))(984(785(202)(192(319(370(663)(14))(438(704(702)(299(991(474)(591))(792(27)(188))))(596)))(803)))(811))))) +(789(549(347(66)(232(216)(334(182)(771(733)(213)))))(807(391(900(181)(983(290(105)(717(802)(875(18)(266(832)(179)))))(944(487(168(221(36)(79))(513(531)(955)))(532))(397(834(826(216)(937))(761))(667(441(870)(464))(67(457)(623)))))))(403(134)(698)))(592(222(425(952)(111))(483(626(25(202)(359(735(95)(950))(428(898)(334))))(495))(239)))(21(768)(224(122(958(980(480(333)(265))(191(7)(974)))(197))(643))(900(552(454(628(925)(864))(422(345)(883)))(459))(639)))))))(215(987(991)(473))(699(657(369(69(666(555(907(220(94)(769))(765(878)(666)))(866(516(874)(942))(955(75)(348))))(117(621(193(670)(94))(343(388)(950)))(269(272(667)(787))(87(684)(161)))))(997(613)(658(853)(680(801(479)(117))(381(100)(866))))))(298))(29(993)(268(135(115(994(554)(787))(709))(56))(889))))(582(343)(698))))) +(78(894(236(464)(309(794(437(372)(581))(604(967(426(157)(869))(411(808)(462)))(361(500(698)(610))(711(184)(755)))))(623(224(102)(360(572(35)(492))(698)))(781(916(150(750)(434))(296))(33(562)(293(286)(7)))))))(334(974(756)(757(272)(867(866(772)(881(776)(845)))(470(147)(950(939)(295))))))(52(64(783(689)(848(710)(702(315)(234))))(659))(553(261(355(730)(375(945)(477)))(391(974(579)(747))(257(662)(578))))(472)))))(781(562(312(370(643(904(223)(218(273)(576)))(933(151(110)(185))(418(680)(805))))(213(766(980)(479(976)(952)))(860)))(303(383(994)(744))(117)))(477))(88(709(182)(224(431)(514)))(205(445(684(593(864)(920(184)(590)))(714(664(890)(466))(70)))(578))(161(686)(43)))))) +(625(138(24(127)(87(799(704(45(53(762(592)(632(920)(338)))(26(134(8)(482))(441)))(133))(520(326(508(762(997)(197))(209(870)(273)))(890(275(700)(789))(9)))(712(325)(968(46(210)(645))(815(185)(127))))))(711(121(742)(591(675(143(800)(138))(633))(558(157)(651))))(758(642(309(430)(276(967)(339)))(425))(295(230)(158(642(98)(146))(353))))))(917)))(792(49(249(953(481(183(753(150)(154(551)(29)))(448(589(229)(760))(83(749)(860))))(131))(91(797(135(888(470)(964))(922(762)(823)))(971))(964)))(223(152)(352(83(590(300)(861))(933(331(640)(817))(502(56)(884))))(825))))(955(767(435(343(249(170(20)(367))(27(428)(907)))(913))(87(929)(328)))(74(116(441(3(877)(146))(835(74)(135)))(829(932(263)(64))(944)))(639(794)(613(27)(815(728)(666))))))(361(184(365)(996(632(20)(69(13)(949)))(922(489(471)(348))(866(337)(627)))))(425(180(438(219)(566))(414(66(811)(674))(397)))(894(551(529(603)(462))(821(710)(544)))(900(698)(43(356)(687))))))))(321(377(200(215)(144))(784(301)(350(349)(100(725(438(366)(154))(839))(866(197(390)(902))(564))))))(729(883(737)(490(409)(118)))(366(420)(444(311(936(629(348)(205))(256(52)(904)))(461(616(47)(111))(471)))(347)))))))(460(721(848(335)(198(972(362)(934))(484(157)(656))))(431(351)(808)))(211(597(996(486(888)(429(937(139)(372(951)(951)))(500(525(954(527)(733))(888(383)(247)))(849(662)(900(941)(344))))))(903))(664))(681(250(557(681(886(694)(57(99)(660(972)(981))))(755(453(786(263)(257))(666))(818)))(62))(36(690)(721)))(27(598(478)(739))(62(968(284(954(699(592)(703))(654(816)(279)))(791))(238))(909))))))) +(406(829(52(802(122(453)(306(227)(255(601(917(640(648)(92))(878))(878))(163(343)(710)))))(830(642(812(899(875(418)(308(739)(436)))(3(186(176)(964))(937)))(829))(893(199(62)(92(388(999)(153))(114(282)(164))))(664)))(186(897(306(926)(268(369(203)(793))(454(691)(749))))(986(702(875)(414(738)(868)))(112(427(61)(334))(587))))(480(534(307(401(489)(415))(641))(37))(743(148(491)(646(38)(947)))(267(889(91)(82))(421)))))))(316))(219(235(770(183)(525(870)(447)))(134(190(796)(215))(887)))(149)))(129(934(774(646(189(430)(181(746)(163)))(750(966(411(761)(48))(151(678(459)(898(200)(87)))(122(144(821)(563))(197))))(663(710)(455(990(778(924)(343))(141(528)(67)))(810(76(888)(887))(776(111)(724)))))))(236(294(494(515(366(793(506)(851))(977(319)(577)))(394))(542))(477(15(133(492(969)(554))(313))(543(367(969)(279))(719(658)(617))))(621(0(49)(845(422)(441)))(153))))(33(115(859(18)(642(274)(48(538)(237))))(628(598)(158(745(461)(599))(696))))(650))))(876(406(931(501(274)(32(370(850(399)(724))(431(810)(376)))(441(103(918)(580))(627(259)(688)))))(444(74(643)(577(2)(799)))(572(71)(27))))(971))(856(83(110)(838(69(804)(94))(897)))(582(322(364(665)(671))(849))(364(840(485(840(185)(242))(801))(231(965(857)(670))(475(888)(381))))(961(822(762(764)(838))(519(723)(402)))(634(434(39)(742))(43(84)(110)))))))))(289(571(177(274)(823))(984(118(921)(884(408(38)(685(48(172)(393))(571(64)(434))))(47(310)(237))))(484(693(207(487(582(867)(93))(855))(56))(755))(934(665(364(600)(852(620)(625)))(393(203(734)(525))(935(470)(656))))(872)))))(899)))) +(219(539(56(513(197(904(65)(576))(252(473)(757(720(869)(574))(908))))(69))(901(115(307(671(429)(897(919)(326)))(91(452(891)(898))(993(179)(950))))(835(925(586)(838(88)(934)))(419(965)(643(70)(83)))))(247(658(866)(281(36(257)(978))(865(753)(27))))(990(262(853)(17(294)(917)))(651(866(365)(998))(419(249)(595)))))))(237(822)(470(394(606)(886(579(243(296)(255))(579))(956)))(953))))(344(508(343(515)(792(283(647(124)(611))(81(548(85)(194))(837(938)(785))))(477(265)(185(499(232)(585))(459(419)(215))))))(156(242)(966)))(117(513(107(798(603(207(759)(129))(120(650)(279)))(85(402)(907)))(911(45(208(960)(14))(732(891)(220)))(927)))(798(240(980(325)(434(223)(205)))(227(813(595)(354))(983(498)(782))))(226(51)(437(873)(255(959)(310))))))(469(545)(172(618(273)(466(808)(205(328)(755))))(835(124(286)(419))(243(742(831)(801))(417(10)(860))))))))) +(869(433(663(632(826(438)(568(22(292(183)(384))(135))(717)))(10))(618(60(291(623)(46(243(208)(665))(298)))(27(25)(563)))(493)))(956(20)(384(720(804(50)(802(214(817)(561))(865(895)(517))))(399(971(715)(872(417)(2)))(902)))(484(11(86)(130))(768(583(95(377)(465))(590))(357(943)(463)))))))(907(32(120(412(227)(138(893)(15(728(436)(300))(940(140)(668)))))(718(401)(777(106(120(940)(508))(912(753)(223)))(698(936(150)(742))(297(993)(701))))))(448(41)(357)))(742(246)(657(697(510(239(289(879)(456))(474))(631(971(970)(958))(733)))(541(449)(736(328(283)(394))(482(293)(788)))))(611(630(206)(713(999)(695(948)(401))))(723(827(919(584)(541))(286(985)(797)))(179))))))) +(784(843(954(100(546(420(21(286)(257))(488(49)(207)))(194))(523(869)(748(106(373)(657))(781))))(599))(948(961(332(105(159(884)(174))(985(759)(407)))(857(329(678)(33))(161(410)(716))))(972))(145(79(73(60)(945))(155(255)(123(518)(103))))(459))))(888(601(356(219)(59))(110(563)(102)))(983(826(727(979(862(776)(148))(807(663)(469)))(447))(926(152(613)(31))(255)))(842(662(965(401)(20(973)(888)))(667(149(774)(844))(519(332)(99))))(142(92(142(860)(526))(657(458)(557)))(128(591)(364(687)(943)))))))) +(216(85(100(562(557(730(989(657)(342))(704(985)(723)))(772(636)(203)))(655))(237(644)(917(839(676)(52(229)(412)))(486(567(128)(484))(757(531)(84))))))(16(169(545)(259))(813(970(894(29(238)(971))(313(426)(855)))(721(335)(586(609)(687))))(213(591(744(856)(18))(489))(708(355(551)(826))(210(515)(890)))))))(231(291(199(970(121(882(800)(652))(719))(953))(590(152)(229(928(200)(677))(776(211)(384)))))(902(775)(200(425)(199(543(117)(197))(762(390)(639))))))(410(953)(190(230)(310(141(534(283)(702))(760(647)(359)))(872)))))) +(285(23(900(846(994(378)(147(430(630(890)(890))(644(855)(887)))(902(522)(846(194)(193)))))(335))(812))(851(466(612(869)(534(750(115)(22))(418)))(53(54(783(862(696)(398))(103(386)(73)))(236(776(164)(213))(293(474)(774))))(828(105)(366(357(920)(322))(732(229)(80))))))(650)))(441(287(729(153(398(761)(597(565(741)(729))(136(526)(316))))(807))(516(461)(85)))(429(561)(767(641(520)(204(833)(100)))(107(370(110)(186(872)(220)))(785(122)(422(751)(293)))))))(358(806)(312)))) +(942(681(997(799)(615(618(595(78(677)(753(948(851)(552(885)(209(355)(502))))(315)))(440(85)(111)))(223(899(616(97)(174(260)(811)))(128(311(789)(974(474(519)(80))(870(596)(899))))(697)))(503(739(263(163)(586(762)(470(342)(207))))(355(282(786(693)(933))(90(160)(36)))(234)))(275(774)(444(83(431(381)(543))(458(42)(969)))(146(2)(995)))))))(244(66)(878(398(216)(273))(300(248(743)(64(549(148)(625))(304(699(801)(993))(1(734)(863)))))(509(676(316)(622(136(828)(140))(910)))(149(551(966)(693(794)(235)))(146))))))))(505(931(116(59(337(69(232(190)(936(702(146)(584))(297)))(84))(705))(346))(990))(86(7(999(637(255)(531(966(39(657)(309))(475(946)(290)))(921(137)(207(365)(190)))))(606(510)(494)))(736))(290(231(957)(441))(973))))(947(28)(438(605(487)(720(510(521(32)(73))(452))(333(810(343)(149(90(700)(275))(846(129)(279))))(102(332(717(180)(289))(598))(90)))))(731(825(815)(958))(952(566(37)(250(464(824(982)(941))(906(821)(258)))(421(2)(426(804)(763)))))(567)))))))(860(328(737)(572(891(418(869(988)(777(759(442(243)(618(777)(555)))(743))(436)))(380(200(38)(859(681(763(339)(232))(150(19)(79)))(655(623(270)(906))(988(478)(208)))))(279(50)(725))))(922(78(713(205)(769(378)(523)))(174))(533(780(251(614)(11))(152))(817(270(639)(996(773(671)(201))(648(582)(764))))(203(902)(367(313(692)(707))(767(24)(277))))))))(271(954(460)(166))(536(496(30)(68))(795(97(212(209(114(66)(378))(592(258)(304)))(344))(651(220(176(202)(27))(132(295)(14)))(995(534(284)(640))(474))))(533(471(473(860(422)(549))(357(675)(914)))(834))(515)))))))(103(569)(42)))) +(911(832(222(261(538(20(900(227)(332))(215(547(586(585(955(900)(107))(194(855)(294)))(885))(253(966(330(142)(130))(822))(246(272(242)(618))(61))))(490)))(679(725(978)(817(118)(444)))(12(290)(448))))(38))(803))(502(222(238(520)(628))(747(496(195(669(3)(656(593(846(559)(521))(142(755)(276)))(647(714(281)(761))(401))))(989(349)(381(673)(213))))(458))(308(913)(224(940(425(347)(668(638)(917(27)(243))))(68))(358)))))(797(989(85(372(278)(645))(737(917)(640(428(980)(338(551(172)(20))(609(642)(452))))(637(113(864(299)(366))(796(935)(336)))(944)))))(607(451(525)(739(110)(489(994)(44(563)(821(983)(719))))))(606(855)(804(245(335(886(154)(154))(383))(592(308(590)(837))(231(719)(358))))(749(0(686(862)(307))(921))(402(574(110)(375))(270(102)(888))))))))(803(753(47(746)(936(620(568(701(659)(466))(98))(644(807(375)(8))(309(666)(577))))(23(263)(80))))(67(990(934(731(736(657)(98))(325(260)(8)))(679(355(718)(823))(285)))(207(625)(666(568)(913))))(329(128)(890(266)(642)))))(169(717)(534))))))(61(105(610)(577(26(410(364)(261(866(803)(429(571)(658(906(117)(752))(880))))(262(376)(836(283(189(576)(492))(331(419)(421)))(129(92(256)(684))(337))))))(332(741(627(73)(612(411(275(485)(603))(808))(63(645(972)(263))(737(613)(297)))))(867(21)(903(9(32)(965(496)(197)))(805(60(350)(584))(858(799)(314))))))(940(411(174(807(33)(854(224)(429)))(999(431(853)(91))(429(533)(958))))(161(810(672(896)(158))(592))(290)))(790))))(276(96)(983))))(548(431)(877(810)(437(939(732)(420))(208)))))) +(322(40(406(697)(653(334(763(814(289)(135))(293))(102))(58(294(533(727)(347))(712(881)(953)))(257))))(161(385(597(437)(342(580)(748(296)(560))))(165(522(366(863)(552))(77))(423)))(485(11)(515(970(778)(931(923)(111)))(257(524)(176))))))(480(14(765(513(988(88(236)(387))(349))(810))(570(515(962(395)(197))(888(642)(66)))(718(438(816)(561))(738(884)(490)))))(687(687(230(953(84)(526))(925))(520))(918(543(19(850)(226))(222(388)(723)))(294))))(440(758(576(807(696(75)(573))(791))(187(888(598)(934))(166(545)(284))))(528))(144(666)(895(586)(669(853(875)(600))(495))))))) +(367(144(971(360(303)(884(12(481(748)(36(196(29)(545(549)(407)))(850(529)(425(628)(291)))))(449(386(428)(545(75(267)(378))(924(207)(683))))(994(865(72)(701(333)(46)))(520(229(399)(545))(633(893)(317))))))(367(808)(317(742(273(711(569)(733))(529))(54(164(505)(707))(206(745)(449))))(159)))))(250(722(335(395)(251(297(544(918)(929))(787(405)(648(520)(132))))(834)))(774(534(549(96(738(766)(586))(825))(768(160(984)(680))(931(793)(235))))(506))(94(802(446(93(799)(359))(891(916)(806)))(597(257(188)(940))(951(613)(750))))(687(878(384)(705(235)(812)))(312(195(379)(196))(131))))))(189(829(353(126(193)(852))(625(675)(160(584(174)(616))(612(752)(848)))))(252))(103(288(752(108(38(630)(212))(539(382)(751)))(99(936(569)(271))(262)))(185(844(118(411)(700))(217))(247(734)(6(253)(650)))))(821(829(197(370(390)(887))(386))(480(249(149)(77))(127(213)(385))))(449(370(217(892)(452))(368(65)(677)))(2(865(809)(643))(439))))))))(353(478(506(614(438(646(142(675)(959(422)(194)))(482(353(795)(660))(486(842)(622))))(400(793)(192(393)(689))))(961))(797))(175))(727)))(552(379(762)(386))(184(283(759(522(854(431(7(951(815)(410))(190))(464))(456(527(810(467)(354))(421))(619(423(947)(361))(130))))(753))(771))(144(753(15(322(754(487(589)(211))(961(34)(340)))(567(840)(712(315)(793))))(487))(730))(485(641)(83(407(730(407)(491(642)(473)))(590(125(688)(787))(347(567)(833))))(850)))))(953)))) +(320(876(21(68(322)(964(724(72(115(177)(985))(721(460)(126)))(726(73(505)(83))(32)))(48(713(749(403)(703))(313))(71(180(385)(210))(736(4)(588))))))(435(182(803(311(715(456)(552))(364(142)(273)))(600(261(195)(824))(883(275)(975))))(644(790(410(88)(651))(414))(161(897(315)(899))(646(967)(442)))))(148(559(21(168(932)(659))(889(124)(505)))(168(682(19)(613))(182)))(381(365(692(449)(764))(225(545)(204)))(979(960(380)(449))(360))))))(815(693(658)(793(649(390(14(260)(685))(370))(624))(22(8(492)(429))(715(451(556)(724))(800(294)(455))))))(377(674(221(524)(207))(329(678)(164(928(822)(934))(222(929)(590)))))(354))))(750(338(806)(482(518(943(337)(843(203(804)(965))(294(964)(156))))(791(495)(373(375(460)(228))(334(681)(163)))))(537(233(931)(501(291(249)(436))(802)))(872(649(358(954)(219))(364))(588(301)(310))))))(831(217(471(825(24(856)(286))(613(21)(450(773)(453))))(382))(100))(343(666(6(93(550)(867(622)(999)))(962(267)(454(878)(698))))(549(816(302)(317(619)(115)))(746)))(692(173(897)(632(367(662)(622))(552)))(18(211(301)(436(995)(804)))(281))))))) +(592(880(594(847(551(266)(120(574)(864(677(801)(662))(577(897)(84)))))(724))(738(983)(106(779(592)(784(141)(716(841)(504))))(848))))(434(752)(265(34(352(413(877(529)(879))(163(658)(71)))(138))(969(278(382)(300(671)(602)))(410(181(198)(767))(847))))(580(888)(2)))))(240(977(609(257(46)(855(254(59)(39))(877(646(604)(919))(839(913)(533)))))(496))(84))(786(667(55)(749(47(250)(891))(260(994(277(862)(138))(439(816)(938)))(544(481(140)(950))(374)))))(864(693(988)(676))(334(79)(959(217)(877(190(178)(276))(869(704)(124))))))))) +(294(453(659(644)(625(75(687(802(311(562(830(80)(262))(805(512)(649)))(156))(43))(122(675(428(119(24)(667))(519(704)(777)))(430(185)(56(839)(684))))(814(223(931(634)(490))(987))(719))))(220))(504)))(863(446(366)(319(140)(453)))(1(922(226(744)(260(496)(288(269(639(248)(496))(940(820)(82)))(708(501)(331(341)(558))))))(698(967(864)(386(759(225(868)(953))(381))(727)))(822)))(604(182(667)(411(35(474)(138(205(64)(783))(495)))(995(300(103)(691(101)(524)))(451))))(644(125)(760(429(615(42(754)(595))(571))(526))(486(439)(700))))))))(912(761(407)(337(999)(896(206)(656))))(151(675(400(119(784(634)(800(673)(675(541(889)(282))(883(206)(884)))))(796(372(384(424(622)(397))(279(314)(36)))(24(474)(961(942)(409))))(343(683(17)(931(75)(284)))(328(29(525)(133))(5(236)(222))))))(882(697(466(727)(844(932)(555(87)(430))))(155(424(551(219)(924))(460(117)(245)))(321)))(35(665(249(6(482)(24))(454))(319(690(802)(430))(946(78)(338))))(67(597(787(162)(675))(653))(678)))))(784))(607(636(561)(505(630)(805)))(743(256)(87)))))) +(346(966(18(883(832(888)(759(549(782(505)(828))(571(341)(645)))(886(375(950)(506))(335(875)(949)))))(22))(357(44)(553(510(856)(488))(587(830(736(408)(864))(114))(864(354(635)(747))(667(774)(211)))))))(725(969)(166(970)(702(747(226)(340(830(371)(296))(496)))(139(765(688)(910(574)(298)))(739(830(817)(798))(809(359)(500))))))))(125(428(389(987(169)(738(678(422(414)(999))(941(852)(303)))(108(942(281)(277))(773))))(401(999)(559)))(655))(73(471(450(836)(18(253(124)(399(105)(736)))(532(510(243)(699))(575(444)(66)))))(834(784(2(345)(22(469)(6)))(752))(258(692(398)(311))(507))))(952)))) +(667(914(684(859)(730(220)(948)))(910(271)(191(644)(433))))(519(915(45(762(253)(94(314)(576)))(652(233)(73(916(511(682)(135(648)(428)))(598))(744(555)(28(516)(19(69(838(575)(40))(792(657)(600)))(210)))))))(998(729(308(520(698)(442(905(398(117(361)(809))(161))(119))(975(273(576)(919))(432(65)(95(264)(770))))))(560))(717(337)(761(491)(366(96(662(754(619)(579))(144))(679(597(724)(594))(876(522)(288))))(436(688(711(115)(861))(134(708)(170)))(533(546)(821(870)(672))))))))(745(109)(633(895(860(614)(735(256(112)(764))(796(237(390)(368))(917(834)(250)))))(184))(844(887)(346(789)(717(854(173(45)(943))(150))(941))))))))(791(669(799(419(874)(732(362)(225)))(981))(185(844(185(474(192(741)(722))(650(981(130(196)(307))(377))(774)))(33(848)(507(532)(33(328(407)(276))(153)))))(809))(189(393)(528(180(328(571(791)(36(154)(896)))(212(632)(153)))(167))(594(184(440(766(727)(683))(508(810)(675)))(966(537(188)(977))(888(65)(80))))(60(618(105)(290(312)(996)))(441)))))))(35(516)(883(805(920(240(382(684)(762(87(743)(5))(936(19)(190))))(697(321(41)(929(905)(934)))(776(919(957)(276))(267(900)(350)))))(136(431(822(272)(708(426)(653)))(592(743(778)(378))(758(689)(302))))(125(816(308)(332(18)(515)))(263))))(775))(501)))))) +(261(541(634(380)(941(594(171(633)(277(387(550)(52))(443(391)(261))))(510(608)(269)))(349)))(835(610(279(127(977(650(378)(442))(75(496)(891)))(298(95)(268(78)(687))))(403(883(529(346)(934))(497(487)(782)))(119(67)(868))))(890(783(160(620)(450(284)(239)))(16(636(194)(139))(207(535)(599))))(699(188)(901(570(774)(770))(554(144)(555))))))(457)))(701(605(235)(856(681(935(763(941(904)(584))(909))(68(409(832)(111))(823(860)(779))))(516))(83(370(831(471(906)(294))(788(673)(824)))(662(772(59)(624))(825(641)(135))))(762(131(644(280)(83))(603(328)(626)))(153(719(667)(451))(770(422)(245)))))))(984(912)(367(540(428(262(926)(65(505)(442)))(955(833(52)(62))(88(720)(865))))(718(442(65(310)(255))(418))(765(179(745)(43))(329(2)(667)))))(118(780(145(38(577)(460))(476))(281(606(957)(833))(984(262)(581))))(492(40(797(343)(98))(146(513)(642)))(577(730(740)(205))(725(997)(546))))))))) +(410(55(51(490(832)(240(429(150)(916(745(204(691)(932))(548(499)(124)))(155)))(90(638(720)(837(827)(600(792)(321))))(603))))(362))(540(88)(459(935(926)(791(128(868(480(402)(255))(51))(478(753(309)(195))(109)))(423(976(621(769)(842))(94))(875(230(42)(772))(483(706)(492))))))(48))))(634(200(825(804(990(978(896)(979(258)(380(380)(498))))(485(54(314)(410))(470)))(686(381(689)(608(937)(192(134)(591))))(952(363(936(169)(486))(771(251)(16)))(122(849(49)(931))(892(996)(97))))))(749(55(497(839)(774(27(648)(343))(46(53)(730))))(711))(569)))(20(358(833(164(857(612(578)(598))(523(440)(769)))(363))(398(111(719(394)(271))(703(912)(463)))(518)))(215(108(467(567(744)(829))(727(77)(723)))(788(57(741)(186))(226(774)(484))))(946(361)(966(29)(29(589)(534))))))(586(238(482(422(894)(261))(315(435(155)(578))(221(864)(622))))(429(398)(255(468(36)(989))(988(560)(926)))))(534))))(729(258(693(145(707(319(674(921)(194))(944(407)(268)))(837(131)(243(616)(881))))(107(899)(348(596(356)(108))(81(131)(66)))))(683))(996))(111(846)(582))))) +(99(760(785(571(577)(217(137(82)(937(453(48(930(388)(227(302)(687)))(848(99(689)(298))(253(856)(179))))(573(644)(695(244)(892))))(838(618(932(807)(896))(107(379)(228)))(367(692)(359(954(973)(794))(890))))))(329(159(633)(654(342(832(930(670)(194))(743))(641(418)(787)))(170(866(94(307)(173))(924(592)(277)))(82(22(460)(239))(333(965)(726))))))(921(995(895(836(212(176)(801))(637))(206(427(476)(738))(330(984)(470))))(647(837(313(892)(182))(524(176)(613)))(265(258(549)(482))(962(846)(519)))))(145(241(290(130(857)(538))(871(325)(7)))(680(140(205)(38))(97(381)(898))))(460(352)(601)))))))(277(857)(137(476(325(243(156(228(916(764)(602))(968(393)(220)))(805))(362))(875(947)(272(350(984(815)(762))(971(593)(691)))(272))))(799(595)(839)))(422))))(665(894(461)(544(880(888(719)(631(215)(829(714(488(129)(941))(628(169)(722)))(830))))(601(934(958(479)(614))(570(988(223)(503(104)(479)))(522)))(575(580(324(873)(158(81)(855)))(549))(701(113(767(545)(454))(164(282)(49)))(807)))))(238)))(91)))(115(46(641)(825(196(418(307(173(550)(152))(400(48(954(18)(965(485)(576)))(271(355(334)(549))(177)))(335(435)(472(94(932)(155))(215(523)(230))))))(473))(885))(635(365(341(835)(774(707(499)(144(757(691)(704))(534(106)(815))))(912(59(101)(301))(636(144(882)(103))(385(10)(687))))))(868))(516(395(321(472(104)(716(639(4)(497))(993)))(838(114)(131(217(588)(944))(780(889)(449)))))(471(927(76(505(729)(58))(929))(749(748(566)(729))(647(758)(285))))(300)))(733)))))(877(978(308(818(493(884(803(97)(62(395)(940)))(312))(461(526(77(520(48)(590))(906))(456(365(901)(264))(65)))(968)))(273(659(782(281(152(65)(953))(944(772)(75)))(976(55(925)(508))(526)))(827(134(673(309)(518))(696(629)(905)))(251)))(307)))(263))(471(447)(5(97(308)(729))(282))))(966(890)(86(977)(32)))))) +(252(556(259(58)(553))(252(553)(232(286(10(126)(654))(949(515(557)(242))(697(346)(638))))(430(704(806(516)(222))(70))(910(287)(865(848)(419)))))))(687(3(95(405)(888))(14(14(223(573)(551(689)(5)))(542(702)(22(211)(237))))(723)))(262(266(274(700(62)(493(640)(496)))(528(397(40)(245))(954)))(87(474)(427(813(916)(650))(916(841)(575)))))(750)))) +(734(442(130(617(578(626)(752(449(907)(888))(610(118)(316))))(538(231(597)(897(537)(299)))(731(776)(41(672)(511)))))(13))(398(303(972(266)(556(660(351)(638))(458)))(767(887)(353(133(152)(801))(997(856)(957)))))(6(427)(351(902(788)(27(105)(580)))(908(953(689)(465))(312))))))(517(963(20(792(287(566(423)(378))(73(727)(642)))(98(685(171)(69))(923(661)(989))))(436(355)(272)))(744))(91(667(164)(665))(473(70(610(431(127)(902))(84(177)(801)))(115(877(472)(927))(187)))(891(48(694(322)(821))(715))(216(509(513)(17))(896(619)(122)))))))) +(655(558(864(315(611(210)(547))(76(24)(409)))(596))(60(797(274(702(902)(307(800(642)(275))(494(625)(30))))(726))(949))(542)))(564(203(155(11(306)(992))(946(509(813)(645))(918(350(866)(815(357)(867)))(234(443(452)(253))(589(587)(407))))))(148(82(829)(878(61(110)(241))(763)))(198)))(485(111(829)(706(36(448(25)(781(963)(304)))(643(514(128)(709))(791(500)(161))))(460(202(250)(96(206)(405)))(736(65)(553(868)(296))))))(447)))) +(728(760(302(553(753(145)(709(773(337(932)(761))(456(991(317)(912(929(589)(132))(136(893)(192))))(511)))(935(817)(493(546(950)(37(841(811)(936))(355)))(356)))))(849))(991(398(963(324(547(382)(655(704(696(471)(166))(483(795)(146)))(517(462)(665(324)(880)))))(456))(628))(659(7)(669(347(921(653)(660(509(183)(903))(55(697)(251))))(575(318)(830)))(332))))(372(932(994(810(431)(683(137(700)(770(147)(52)))(946)))(336(580(43(954(517)(29))(568))(318(185(677)(107))(586(318)(926))))(108(412(802(33)(128))(173))(834))))(764))(603(60(877(248(613(571(833)(126))(357(290)(333)))(617))(671(384(12(39)(452))(752(137)(561)))(181(288(684)(929))(730(693)(961)))))(866(22(883(312(867)(159))(114))(901(37(956)(619))(190(436)(152))))(504(620)(538(686)(417(31)(758))))))(864)))))(891(369(935(818(949(141(258)(82(98)(99(385)(157(860)(651)))))(997(677(205(959(35)(78))(145(919)(470)))(121))(465)))(946(26(815)(607(298(971(615)(851))(685(892)(541)))(827(956(253)(784))(833(657)(389)))))(352(966(314(53(346)(468))(141(957)(208)))(170(32(873)(985))(511)))(94))))(780(353(609(87(365)(421(103(836)(15))(894(665)(214))))(171(201(441)(682(857)(312)))(259(291)(668(176)(592)))))(269(244(927(672(642)(333))(32))(877))(562(325(62)(875(68)(796)))(530(933)(259(756)(690))))))(595(895(456(543(919(226)(578))(890(158)(379)))(117))(907))(308(202(34(150(807)(241))(590(100)(877)))(980(137)(955(826)(732))))(106(650(929(326)(631))(780))(940))))))(19(1)(998(893(516(140(24(28(900)(149))(926(387)(913)))(484))(106))(789))(689(953)(679)))))(141(718)(500(603(801)(285))(781)))))(376(250(810)(68))(659(99(184)(776(822(553(548(345(181)(571(169(224)(644))(790(575)(939))))(62))(598))(718(283(711(929(678)(519))(628))(762(146(421)(514(289)(602)))(347(135(126)(683))(764(653)(588)))))(804(486(872(523(70)(247))(693))(230(33)(767(629)(956))))(430(48)(13)))))(59(717)(249(211(94(581(26)(424(568)(890)))(162(980(738)(64))(892(563)(879))))(10(623(450(87)(53))(836(981)(705)))(375(658(481)(49))(887))))(798)))))(617(178(728(646)(543(454(95(131)(377(152(406)(54))(654(155)(835))))(787(731(61)(785(354)(215)))(100(10)(692))))(399(569(790(330(351)(218))(868))(681(622)(66)))(443(993(524)(876(741)(557)))(59)))))(388(680(988)(167))(255(761(181(195(250)(903(457)(290)))(374))(352(194(911(972)(331))(2(746)(139)))(914(750(312)(991))(594(744)(773)))))(380))))(730(867)(241(745(933(904(916)(616(398(0)(95))(10(158)(642))))(816))(120(267(931)(466(821(528)(222))(567(376)(668))))(200)))(811(285(1(894)(719(972(379)(650))(422(994)(10))))(239))(120(259)(748(61(521(426)(755))(344(181)(600)))(640)))))))))) +(502(740(856(332(132(113)(964(502(925)(22))(195(997)(705))))(771))(385))(107(790(771(677)(639))(663))(861)))(728(986(362(559(524(720)(458(853)(589)))(450))(21))(993(230(581)(157(206(957)(270))(190(686)(205))))(327(374(769(571)(776))(143))(754(192(215)(393))(827(307)(951))))))(159(731)(924)))) +(79(999(151(586)(56))(631(606)(400(276(881)(748))(952(641(701)(249(281(821)(661))(554)))(881)))))(829(963(946(373)(604(377(805)(372))(828(243(665)(373(342(72)(998))(979(68)(247))))(938(98(802(105)(597))(570))(550)))))(667(468(442)(626(444)(580(337)(553))))(830(597)(151))))(898(58(404(235(325(888(251(574)(961))(687))(28(845(313)(977))(297(638)(240))))(868))(712(410(699)(447))(577(462(786)(870))(423))))(206(437(129(905(711(407)(298))(14))(635(201)(627(226)(135))))(781(646(384)(263))(590(454(77)(235))(145))))(996)))(6)))) +(896(250(11(658(389(504)(159(576(920)(836))(608)))(617(31(997(648)(647))(392(859)(846)))(855(513)(326))))(321(715(446)(929(908)(839(815)(337))))(590(338)(743(7)(446(28)(385))))))(439(838(14(736(256(177)(398))(866(653)(23)))(395))(953))(51)))(229(970(93(380)(999(251(339)(711(915)(300)))(428(472)(810))))(379(392(551)(86(700(593)(546))(788(897)(477))))(385)))(253(98(648)(717(642(196(749)(213))(736(395)(250)))(814(44(223)(990))(249(894)(338)))))(516)))) +(29(594(488(63)(746))(997(110(76(330)(579))(730(965(779(201(95)(14))(80(551)(760)))(577(329)(780)))(616)))(505(784(610(481)(452))(472(533(782)(961))(777)))(623(301(677)(803))(706(261(703)(718))(303(503)(556(618)(747))))))))(612(840(65(588(991(385)(203))(848))(571(301(224(260(518)(321))(222(237)(881)))(763(41(927)(59))(826(16)(249))))(816(209(912(74)(57))(18(343)(378)))(399(694(784)(523))(525(825)(903))))))(901))(729(749(4(329(515(382(80)(183))(25))(495(884(167)(284))(413(151)(864))))(477(603(144)(188(631)(341)))(790(897(334)(473))(1(163)(818)))))(500(299(749(922(601)(775))(751(832)(830)))(405(83)(222)))(33(167(664(340)(920))(163(824)(126)))(581(709)(861(373)(559))))))(568(94(697(229(785(497)(393))(214))(704))(121(969(28(444)(583))(870(254)(618)))(685(159)(284))))(194(22)(26(996(70(122)(769))(987))(464(598(601)(319))(192(912)(166))))))))) +(662(884(946(656(795(367)(60(626(56(704(241(740)(45))(465(122)(207)))(260(708(589)(916))(245)))(593(465(322(753)(630))(448(285)(451)))(481(321(78)(746))(413(145)(477)))))(602(942(217(176(456)(666))(2(503)(253)))(670))(948(510)(587(432(335)(533))(451(743)(224)))))))(376))(40))(868(453(680(795(788(284)(422(1(109)(805(750)(298)))(427)))(674(350(364(613(881)(33))(629))(812(891(135)(886))(263(625)(482))))(740(482)(520(591(821)(224))(774(670)(78))))))(379(101(743(867(548)(429(315)(984)))(267))(767))(827(724(212(516)(8))(229(980)(260(239)(229))))(383(883)(888(12(479)(527))(666))))))(751))(716(573(997(926)(67))(554(461)(3(12(974(840(997)(788))(907))(363))(604(787)(435)))))(550(958(475(968(866)(704(702(357)(59))(313)))(51(355)(119(352(669)(423))(673(389)(56)))))(255(484(316(545(468)(112))(501(649)(513)))(83(33)(542)))(754(343)(950(390)(393(659)(163))))))(736)))))(771(765(521(11)(16(437(352(570(461(608(433)(476))(907(805)(167)))(674))(453))(959(389(861(22)(685(23)(76)))(807(955)(438(32)(133))))(401)))(229(919(152(942)(673(393(391)(330))(213)))(274(408(447(491)(581))(324(26)(526)))(425(88(315)(420))(427))))(838(613(728(584(122)(435))(693(621)(393)))(809))(750(309)(332(772(922)(127))(436(238)(229))))))))(50(350)(312(609)(925(389(781(451(935(311)(368))(377(896)(777)))(811(641)(66)))(437(828)(420(48)(42(853)(938)))))(337(787)(288(487(313)(544))(68(394)(685))))))))(817(496(397(594(930)(119(720(49(785(418)(298))(826(508)(605)))(912(444(16)(411))(227)))(304)))(970))(14(176)(959)))(145(81)(161(895(378)(5(58(839(10)(508(542)(227)))(85))(261)))(616(861)(958(245(934(570(895)(102))(721(125)(311)))(631(544(51)(699))(191(290)(948))))(765(287(411)(202(241)(876)))(62(104)(238(654)(993))))))))))) +(801(628(263(35(303(401(417(942(141)(222))(426(527)(124)))(836(913(853)(773))(688(908)(220))))(430))(306(572(505)(183(888)(880)))(208(92(154)(137(0)(600)))(736(206(888)(450))(326(789)(114))))))(735))(304(942(393(892(984)(507(588(516)(99))(734(784)(999))))(925(446(612(752)(353))(339(730)(676)))(89(231)(685(461)(609)))))(828(268)(76(686(557(499)(177))(77(917)(18)))(266(24(934)(910))(837(226)(895))))))(948(666)(748(198(100)(994(592(637)(434))(253(858)(804))))(433(532(357(83)(145))(635(371)(995)))(144))))))(137(597(929(62(422(717(816)(301(638)(25)))(123))(132))(404))(843))(471(146)(536(896(822)(959(769(172)(284))(853)))(156))))) +(704(294(634(743(365(112(182)(488))(675(586)(822(968)(278))))(809(481(679(389)(765(73(810(782)(989))(286(445)(390)))(51(327(509)(350))(208))))(854(85(760(375(915)(954))(626(168)(243)))(61(83(786)(785))(709)))(73)))(133)))(178))(318(177(501)(316(621(364(447(980)(24))(546))(383(799(854(790(130)(963))(775(657)(30)))(30(222)(614(789)(874))))(630)))(371(710)(792(144(883(273(497)(162))(257(992)(463)))(767(614(324)(371))(566(43)(219))))(992(649(282(900)(797))(844))(462(53)(617(527)(139))))))))(698(272)(177))))(304(197(683(442(533(947(664)(253(212(679(858)(74))(158))(269)))(862(678(177(631(90)(180))(956(748)(755)))(322(373)(451(838)(371))))(792(851(715(302)(179))(609(732)(161)))(213(524(563)(746))(710)))))(264(106(251)(130))(774(285(24)(55(685)(618(783)(621))))(40(329)(244)))))(661(219(615)(808(314)(899(749(933(595)(432))(855(799)(882)))(706(231)(345(614)(238))))))(520)))(986))(997(730)(806(911(495)(292(255(29(379)(243))(473(319(740(719)(49))(697(820)(419)))(173(526)(251(513)(817)))))(13(284(83(602(470)(421))(752(432)(0)))(276(495(536)(675))(150(124)(534))))(510(857(502(721)(476))(649))(922(784)(440(721)(991)))))))(354(938(736(750(196(804(315)(124))(203(502)(810)))(838(416)(346)))(627(401(618(717)(468))(213(703)(163)))(637(101)(428(622)(153)))))(284(972(11(917(902)(317))(561(50)(289)))(597(663(742)(687))(772(688)(32))))(563(618)(38(9(236)(225))(905)))))(22)))))) +(503(796(915(843(514)(392(618(218)(289(733(709)(229))(408)))(206(25(93(680)(891))(391(268)(964)))(66))))(265(889)(157)))(808(302)(727)))(824(403(31(16(314)(465(474(604(6)(414))(294(246)(728)))(718(326)(51))))(832(910(174)(181(38(750)(199))(762(760)(980))))(864(229)(333(493)(391)))))(960(798)(336(437(587(299(294)(41))(349(227)(906)))(371(517(965)(226))(449(500)(51))))(807))))(544(194)(642(620(325(743(829(151)(700))(802(619)(173)))(345(689)(572(540)(28))))(290(675(515(309)(124))(330(847)(385)))(626)))(730(826)(413(797(807)(170(185)(885)))(217(851)(531(548)(493))))))))) +(840(452(552(6(903(632(381)(113(399)(353)))(180(504(121)(825))(605(57)(407))))(840(651)(1(387(358)(755))(520(647)(962)))))(837))(356(759(533(731(160(228)(548))(522(225)(461)))(379(156(667)(777))(438(200)(572))))(211(19(184)(863(928)(237)))(326(221(829)(867))(765(709)(743)))))(446)))(994(332(763(683)(957(821)(313)))(223(362(645(270)(921(232)(281)))(926))(133)))(957(736(851(236(848)(741(706)(90)))(378))(405(989(696)(884(995)(991)))(179(805(420)(464))(49(627)(88)))))(362)))) +(179(734(868(218(212(776(704(477)(639))(237(325)(127)))(821))(449(449(502)(362(680)(613)))(998)))(170))(648(331(736(47(325)(215))(375(134(607)(384))(273)))(517(570(665(93)(752))(826(230)(480)))(814(952(960)(644))(632(139)(675)))))(797(918(761(658(273)(628))(993(585)(874)))(307))(862(680)(138(596)(705))))))(904(144(251(620(467(185(431)(795))(668(398)(398)))(134(929(539)(451))(236(724)(555))))(989(824(562(471)(601))(101(210)(14)))(444(301)(755(127)(384)))))(684(524(676(95(460)(605))(323(717)(269)))(99(243(31)(875))(634)))(977(738(92(828)(581))(478))(340))))(534(584(838(641(516(405)(334))(220))(423(913(140)(593))(271(269)(499))))(594(534(646(475)(358))(252(94)(385)))(697(771)(542(353)(108)))))(744(867(396(225(788)(433))(933(406)(416)))(16(933)(52(78)(290))))(327))))) +(568(749(107(784(197(580(979(980(336)(392))(597(80(101)(315(188)(179)))(941(482)(821(112)(546)))))(745(316(209)(308(582(665)(745))(253(177)(756))))(797(487(403(234)(640))(190))(296))))(632))(537(879(442(236)(58(303(947(684)(262))(704(31)(990)))(543)))(269(276)(632(578(127(319)(409))(113(311)(284)))(964(572(811)(170))(573(932)(446))))))(305(789(70(96(401(592)(151))(76(832)(759)))(352(663(7)(144))(768)))(14(34(457(618)(808))(75(956)(915)))(178(370(189)(409))(938(947)(920)))))(258))))(642(876)(902(735)(710(761(318(236(504(974)(113))(222(96)(616)))(982(577(761)(920))(940(420)(725))))(622(863(578)(291(806)(307)))(527(711)(978(860)(220)))))(191(228(758(745(221)(774))(57(85)(400)))(40))(509(979(28(93)(60))(868))(26)))))))(650(237)(47(502(956(563(630)(48))(30(764(652(327)(282(412)(817)))(456(96(400)(395))(685)))(608(732)(96(659(268)(696))(329)))))(499))(121(392(495(681(759(330(214)(297))(42(826)(18)))(462(939(25)(442))(13(879)(859))))(640(751)(442(855(234)(468))(512(474)(408)))))(51(282)(68)))(730)))))(822(176(180)(691(521(676(830)(81))(897(889(898(10(691(236)(482))(468(304)(218)))(517))(725))(87)))(833(84(456(79(656(101)(293(433)(880)))(0(91(915)(280))(118)))(213(696(816(385)(582))(955(460)(622)))(298(667(868)(590))(859(984)(301)))))(932(621(69(543(89)(959))(678))(932(995)(367(585)(912))))(243(768)(970(890(397)(50))(175(463)(858))))))(870(987(902)(793(245(598)(181(556)(741)))(794(566(606)(23))(144(974)(113)))))(616)))))(138(294)(817(682(23(686)(621(57(469(0(165)(458))(939))(744))(679(359)(520))))(951(20)(720(919(382(346(227)(563))(581(75)(737)))(526(492)(988(338)(481))))(173(801(534(421)(997))(908(513)(767)))(85(837(577)(754))(705(300)(246)))))))(622(93)(794)))))) +(266(36(732(651(967(999(294(444)(272(901(19)(737))(594(832(563)(42(679)(909)))(148(118(773)(289))(526)))))(414(771)(927(577)(635(596(874)(466(507)(186)))(346(474(418)(696))(971))))))(260(379)(173(984(25(366(498(711)(978))(364(704)(854)))(762(23(32)(186))(917(149)(719))))(72(512(995(492)(156))(14(495)(633)))(998)))(605))))(495(699(164(979(526(591(250(153)(373))(546))(846))(426(550(788)(463(224)(467)))(969(398(940)(166))(613))))(36(335)(595)))(587(490(34(161(73(888)(542))(470))(130(181(193)(24))(161(893)(422))))(752(518(71)(23(578)(863)))(533)))(122)))(296(278)(615(942(85)(441(16)(697(318(947)(602))(831(979)(926)))))(261(121)(291))))))(819(241(391(454)(879(5)(324(237(914(760)(805(885)(486)))(980(85(457)(481))(938)))(48(765(928)(240(394)(904)))(266(783(956)(362))(685(376)(530)))))))(683(640(334(300(772(941(271)(847))(415(314)(412)))(263))(843(180)(911)))(540))(883(879)(819(430(396(526)(335))(846(605)(538(620)(83))))(713)))))(33(614(141(577)(590(375(538)(974(784(190)(123))(995(274)(790))))(650(631(541(891)(107))(8(885)(327)))(539(508(933)(962))(217(890)(312))))))(375(520)(6)))(871(99(711(314)(153))(296(390(479(924(23)(284))(148(766)(244)))(1(366(838)(291))(854(911)(781))))(848(436(802(268)(956))(960))(330(145)(443(353)(67))))))(586)))))(74(417)(74(376(879)(784(271(992(843(220(184(444)(568))(36))(741))(557))(150(125(825)(281(40(20)(389))(913)))(46)))(834)))(405(321(937(729)(288))(445(388)(273(256(13(792(38)(649))(661(257)(329)))(174(899(701)(264))(47(350)(452))))(251))))(534)))))(224(431(869(877(17)(95(83)(695)))(718))(276(647(181(41(120(209(119(472(305)(496))(843))(483(171(657)(179))(448)))(390))(352(671(628(805)(454(927)(952)))(210))(262(800(565(702)(260))(664(510)(486)))(317(364)(34(303)(396))))))(622(778)(546)))(279(356(613(947(910(626(806)(708))(59(769)(630)))(984))(996(1(739(449)(386))(986(917)(915)))(204(680(921)(507))(868(468)(661)))))(576(965(935(727)(26(447)(89)))(321(976)(119)))(519(877(779(687)(322))(25(993)(430)))(356(903(109)(181))(189(220)(490))))))(78(404(644(271(682(417)(470))(405(327)(430)))(265))(444))(123))))(622(691(292(881(549(561)(496(198)(654)))(744))(541(7(580)(671(313)(426(679)(687))))(735(399(351(321)(671))(82))(487(690(811)(847))(377(638)(860))))))(817))(319))))(766(841)(499)))) +(626(134(15(117(906(278(110(566(407)(722))(589(365)(624)))(369(320(87)(483))(48(751)(540))))(950))(838(545(505(280(807)(853))(205(216)(880)))(676(457)(302(892)(608))))(49(195(357(477)(32))(999(846)(699)))(257))))(286(981(205(616(990)(21(578)(527)))(545(297(93)(389))(811(516)(875))))(257(880(741(736)(861))(236(64)(430)))(823(767(687)(308))(9(748)(879)))))(487)))(297(102(157(10)(105(433(254)(90(304)(472)))(687(456)(72(32)(180)))))(378(25(328(109(616)(959))(443))(918(732(581)(984))(66)))(517(655)(110))))(977(16(516(631(217(501)(201))(976))(985(866(571)(698))(176(351)(764))))(336))(93(759)(623)))))(718(274(97)(88(626)(107)))(165(127(78)(167(282(76(584)(294))(906(993(55)(526))(840)))(182(671)(753(535)(946(22)(895))))))(340(190(669(411(464(848)(239))(647(706)(187)))(772(41(64)(756))(849(239)(747))))(840))(224(614(36(233)(326(721)(879)))(344(62(284)(203))(614)))(504(247)(386(995)(110(167)(203))))))))) +(594(992(560(64(251(42(7)(36(23(104)(603))(433)))(369(715)(178(37(261)(975))(837))))(286(953(606(312(5)(284))(957(26)(138)))(808))(321)))(759(516(658)(464(898)(363)))(22(23(446(268)(784(31)(954)))(184(830(267)(797))(857(194)(426))))(670(474)(140(636(726)(787))(333))))))(924(299)(704(447)(316(215)(866(642(828(382)(151))(562(66)(570)))(418(719)(688(575)(748))))))))(348(533(241)(860))(307(908)(199(876(317)(465(426(630(378)(349))(528(21)(912)))(599(267(847)(809))(76(10)(98)))))(441(913(175(466(268)(953))(790))(157(862(974)(809))(925(888)(863))))(504(746)(500(982)(350)))))))) +(642(19(981(379)(316(85(903(548(115(551)(876))(664))(352(794(137)(88))(772(668)(719))))(63(691(694(741)(9))(149(573)(921)))(258)))(573)))(283(776)(59(392)(955(240(754(601(272)(194))(822(217)(944)))(998(646)(219)))(342)))))(18(532(86(215(289)(413(226(484(569)(835))(922))(589(728)(0))))(480))(263))(511(11)(32(406(519)(788(221(22(940)(577))(541))(772(247(721)(991))(785(600)(751)))))(526))))) +(178(616(609(309)(215(292)(626)))(359(579(620(220(904)(225(461(859(351(80)(187))(535(511)(72)))(568(118(733)(817))(334(284)(875))))(283(862(486(210)(510))(877(137)(991)))(652(382(576)(674))(0)))))(185(665(824)(819(939(803)(937(650)(400)))(510)))(179(790(394)(622(174(417)(421))(774(689)(888))))(434(38(138)(771(360)(641)))(893(798(539)(613))(298(866)(381)))))))(559(769(524(529)(290))(57(808(141)(365(780(563)(279))(543(504)(11))))(751(904(367)(20(380)(620)))(743(705)(347)))))(886(620(908(473)(936))(170(924(569)(243(447)(569)))(161)))(575))))(933)))(942(519(24(641(38)(687(672(43(811(859(595)(531))(716(930)(414)))(622(864(164)(754))(174(308)(767))))(533(626)(429)))(829(688(634(716(391)(950))(944))(798(63(912)(955))(558(155)(26))))(878(952)(973(409)(885))))))(691))(287(836(912)(492))(627(819)(41(738(808(777(696(203)(801))(18(126)(882)))(583(433(695)(57))(430(905)(841))))(882(301)(829(425(909)(710))(903(86)(454)))))(661)))))(378(575(329(634(341(401(108(409)(918(314)(866)))(40(436)(841)))(940(409)(832)))(741(817(481)(563(464(210)(163))(19(651)(653))))(212)))(484))(396(701(600(967(812(858)(762))(753))(13(834(386(632)(272))(523))(695(400(316)(316))(748(845)(442)))))(240(7(910(636(942)(862))(582(110)(696)))(523(951)(725(782)(751))))(12(971)(390(11(650)(996))(834)))))(665(363(322(246(666)(544(356)(317)))(233(122)(245(176)(101))))(820))(809(626(933(0(570)(762))(892(180)(72)))(294(28(863)(135))(305(552)(965))))(465)))))(777(810(172(436)(847(828(385(838(836)(379))(987(692)(580)))(149))(66)))(362(474(436(581)(549))(360(347(199)(956(898)(53)))(700(299)(830(926)(525)))))(441(713)(946))))(317(42(378)(226(789(806(451(198)(859))(570(233)(468)))(508))(596(114(95)(233))(865(454)(444(252)(674))))))(940)))))) +(921(84(278(331(133)(942))(173(139(406(314(510)(656))(963(307)(503)))(370))(815(143(4)(168(123)(613)))(62))))(203(857(641(309(868(773)(697))(475(183)(97)))(316(767(256)(959))(319(475)(27))))(192(49(733(155)(755))(142(568)(654)))(841)))(572)))(914(311(813)(148))(55(545(880(480(257)(567(94)(150)))(779))(502))(731(988(21(644(298)(105))(164))(179))(676))))) +(444(439(690(270(836(864(967)(763(222)(329)))(213))(797))(257(709(12(937(555)(544))(442(236)(649)))(264(878(843)(689))(869)))(911)))(622(313(737(337(254(264)(645))(561(40)(891)))(966(742)(892(967)(14))))(979))(772(646(650(451(368)(983))(479))(25))(907(837(368(326)(446))(715))(962)))))(639(589(860)(180(72)(680(231)(120(445(607)(613))(121(840)(90))))))(160(984(669(288(898)(191))(989(572)(889(232)(867))))(301(969)(623(541(815)(624))(252(316)(879)))))(560(702(38(97(980)(394))(958))(204(583(659)(402))(39(752)(412))))(416(756(252(49)(837))(954(640)(605)))(731)))))) +(193(527(973(446(167)(603(268)(451(599(412(24(368)(885))(568))(215(647(523(393(105)(404))(354(539)(911)))(378(752(46)(581))(827)))(942(504)(154(802)(635(464)(350))))))(170(830(269)(312(857(76)(734(378)(158)))(256)))(580)))))(267(14(264(906(760(207(897(421(335)(523))(633(687)(481)))(966))(485))(918(826(914(343(962)(503))(47))(550(228)(243(944)(993))))(50(407)(608(433)(903)))))(413(651(939)(48(385(128)(583))(218(188)(900))))(920(960(589(434(464)(281))(573(542)(672)))(807(62(280)(129))(770)))(361(645)(962(403)(562(193)(894)))))))(990))(529(305(560)(623(935(36)(711))(221(322(969)(161(405(534)(603))(869(966)(249))))(185))))(497(410(689)(642))(316(749)(534(149(306)(678(935(278)(890))(155(923)(724))))(869(210)(734(511(637)(147))(220(606)(871))))))))))(866(379(198(422)(589(197(156)(569))(770(689(474(600(312(382)(477))(534))(155(84(313)(343))(890(445)(313))))(808))(879))))(435))(613(579)(120(432(14(714)(491))(868))(861(844)(93))))))(535(657(983(508(158(630)(970))(455(100)(168(676(890)(353(986(401(658)(935))(213(672)(265)))(201(472(553)(536))(476(397)(793)))))(368))))(277(418)(354(897)(779(267(762(700)(305(758(183)(611))(152(567)(653))))(680))(304(395(622(26)(425(792)(148)))(307(50(378)(212))(582)))(508))))))(993))(210(681(23(536)(811(445(152(671(22(896(856)(73))(594(538)(80)))(948(36)(842(220)(411))))(251(135(395)(86(201)(137)))(107(665(935)(305))(445(174)(915)))))(611(145(406)(713(181(558)(258))(339(736)(794))))(783(54(427(674)(640))(404))(776))))(670(422)(935(422(331(433)(24(654)(549)))(394))(669(754(656)(801(512)(248)))(666(904)(299)))))))(733(48(986(260(205)(362(950(590(896)(901))(773(142)(382)))(517(755)(766(795)(340)))))(137(690)(367(955)(680))))(868))(869(18)(666(342(804(806(339)(292))(482(232(420)(276))(764(949)(455))))(28(43(374(142)(542))(202(158)(62)))(570(811(330)(105))(304))))(375(209(464(737(669)(457))(311))(505(514)(586)))(322(338)(535(843(157)(824))(801(342)(497)))))))))(485(346)(882(801)(250(638(316(4(849)(288(241)(757)))(169))(572(308(502(254)(558(744)(699)))(972))(55)))(738(154(89(736)(997))(983(884)(448(498(885)(454))(840(187)(49)))))(276(791)(107(112(550(24)(109))(889))(199(888)(679(917)(585)))))))))))) +(150(648(364(555(790(992(428(668(860)(521))(80(317)(177)))(143(871(753)(617))(760)))(707(782(739(605)(358))(213))(293)))(888))(357(79)(486(546(774(596(984)(73))(655(494)(0)))(232))(845(626(85)(673(526)(423)))(234)))))(677(471)(157(898(135(764)(913))(684(303)(711(687)(94(465)(755)))))(416(585)(215(156)(196(964(54)(268))(227(901)(815))))))))(667(295(574(535(609(969(843(901)(978))(85(551)(696)))(467(971(263)(585))(910)))(958(64(514(956)(91))(967))(343(820(388)(733))(672(811)(411)))))(594(827(705(658(740)(415))(220(438)(821)))(372))(380)))(995(950(887(468(794)(644(81)(393)))(743(918(64)(297))(615(737)(662))))(714(646(160(22)(477))(238(595)(934)))(655(419(995)(494))(275))))(19(934(287(350(995)(526))(815(287)(700)))(657))(217(258(548(492)(234))(0(609)(129)))(623(910(407)(90))(819))))))(448(210(802)(488))(763(93(194(276(440)(39(349)(137)))(683(561)(286(765)(324))))(968(196(849(282)(451))(803(247)(949)))(201(163(554)(469))(641))))(92(687(281)(193(780)(745(44)(376))))(894(337)(547(632(400)(108))(132(564)(903))))))))) +(920(126(443(750)(378(337)(148(226)(226(407(233(152)(557))(819))(773(248(714)(832(63(210)(589))(326)))(755(739)(391(658(225)(996))(54))))))))(225(662)(943)))(241(922(95)(547(359)(326(390)(577(291(138(16(235(155)(230))(536(81)(825)))(157))(285(827(345)(560(492)(887)))(788(286(922)(519))(433(990)(977)))))(181(540(810)(899(539(9)(152))(996)))(59))))))(346(949(18(872(207(714(633(564(809)(501))(505(529)(861)))(385(406(966)(776))(669)))(601(305)(422(119(459)(789))(441(219)(293)))))(637(795)(898(96(264(220)(681))(712))(793(198(96)(100))(204(566)(668))))))(969(880(853(858(101(44)(884))(840(265)(513)))(613(841)(950(672)(254))))(972(112)(793(16(834)(984))(625(837)(139)))))(140(215)(497(868)(530(898(775)(679))(738(73)(963)))))))(159))(98)))) +(231(604(477(11(561)(237(719(224(373(84(982(340)(583))(667(433(369)(560))(235(363)(315))))(60(213(794(663)(349))(908))(483)))(586(693)(607(430)(918(800)(84(326)(310))))))(348(328)(56(59(630(828(654)(590))(66(643)(368)))(261(583(671)(999))(155(637)(482))))(87))))(824(772(472(616(71(50(753)(496))(86))(545(446(543)(639))(979(82)(272))))(884(554)(672(48(634)(128))(356(245)(564)))))(792(769(461(199)(848(82)(961)))(446))(100(830(269(451)(304))(507(966)(62)))(665(323(168)(986))(65)))))(157))))(138))(738(619)(573(543)(643(991)(565(619(81(406(655(412(923)(626))(216))(806(585(702)(793))(152(541)(302))))(51(287)(122(861)(753(806)(682)))))(490(311(724(104(311)(240))(922))(933))(847(252)(240(294(418)(495))(659)))))(915))))))(416(822(299)(343))(665(987)(599(13(713(708(986(172(697(150(510)(255))(398(176)(315)))(12(187(483)(932))(943(831)(587))))(637(361(782(613)(399))(150(234)(753)))(162(133(155)(114))(943(579)(880)))))(619))(791))(504(554(202)(118(458(940(410(597)(464))(136(640)(463)))(686))(145(360)(666))))(599(705)(912(560)(896)))))(158(107(467(649(894(872)(402(190(732)(553))(924)))(243(686(865(679)(486))(237(101)(100)))(742(607(540)(258))(353))))(829(521(372(915)(933(613)(425)))(146))(27)))(482(543)(397)))(545(979(268(356)(695(9(554(795)(609))(879(246)(567)))(388)))(829(508(635(837)(97(994)(564)))(751(634(998)(880))(6(279)(317))))(710(20(173(27)(182))(520))(935(977)(680)))))(854(990(423(1(367)(152))(503(794)(143)))(605(602(170(788)(829))(899(244)(778)))(886)))(253(195(336)(123(90)(905(734)(111))))(298))))))))) +(430(653(443(105)(232(443)(42)))(720(69)(892(555(236(236(980)(424(469)(333)))(228(829)(355(657(816)(411))(562(54)(807)))))(385(785(31)(114))(731(103(730)(486(757)(770)))(503(497(323)(219))(689(763)(502))))))(372(788(972)(269(793(698)(859))(965)))(765(418(334(663(588)(399))(244))(373(614(897)(232))(488)))(476(723)(568(426(284)(818))(739))))))))(883(715(61)(760(128)(767)))(475(210(447(99(681)(66(942(563)(806))(545(541(975)(226))(549))))(317))(742))(384)))) +(352(389(685(369)(593(172(379(229(63(402(852(181)(832))(254(856)(917)))(105(86(732)(753))(896(39)(955))))(821(464)(58(475(779)(454))(567(152)(941)))))(24(640(873(124)(53))(133))(479(444(887(776)(733))(709(892)(564)))(1(872(756)(95))(834)))))(259(140)(920)))(130(834(312)(311(211(171(919(417)(990))(845))(353(877(718)(877))(483(413)(637))))(862(258(820)(61(820)(381)))(817(15)(156(613)(245))))))(506(762)(431(479(161(815(394)(90))(255))(191(300)(327(647)(268))))(461(397(548(465)(935))(513(736)(150)))(941(700(569)(788))(440))))))))(72(26(193(891(685(428(267(187(165)(175))(296))(440(659(408)(974))(826(365)(204))))(690(309(531(559)(333))(375(21)(529)))(357)))(837(106(729)(227(684)(357(257)(340))))(683(981(240(758)(494))(184))(550(250(438)(428))(161)))))(960(717(379)(94))(116(750(873(947)(195(130)(605)))(945))(194(806(633)(487(667)(607)))(790(897)(588(472)(873)))))))(959(975(691)(515(145(896)(917(688(384)(958))(109(503)(752))))(905(139)(826(880(748)(789))(202(76)(0))))))(541(705(249)(165))(703(580(959(950(607)(756))(909(208)(648)))(337(749(550)(167))(555)))(225)))))(36(607(941(821(926)(438))(951(523)(268(878(448(300)(917))(942))(678(364)(37(438)(650))))))(286(204(978(35(726)(229(615)(151)))(94(384(482)(625))(792(621)(535))))(370(377(925)(109))(887)))(726(935)(535(20)(736)))))(140(782(755(626)(319(834(461)(547(348)(824)))(531(671(692)(45))(504(663)(858)))))(913(933(72(774)(897(82)(106)))(636(179(749)(526))(24(869)(801))))(738)))(513)))))(735(739(276(620(147(78(148)(941(336(190(475)(408))(489(902)(249)))(293(749)(522))))(232(916(498(703)(983))(408(659(533)(54))(986)))(899(272(948(829)(595))(627))(892(153)(534(339)(421))))))(887))(484))(157(328(120(516)(517(108(321(930)(883(902)(752)))(273(474(612)(204))(419(175)(199))))(756(907(195(296)(582))(309(943)(787)))(946))))(780(339(328(371(289(330)(232))(602(508)(420)))(36(271(563)(440))(593(692)(809))))(909(831(64)(961(509)(409)))(77(672(822)(750))(111(952)(397)))))(974(850(481(872(264)(975))(435(255)(791)))(786(823(696)(180))(235(636)(437))))(486))))(391(270)(732(870(810(665(338(55)(387))(20))(755(131)(876(585)(385))))(528(157(153(816)(48))(717(158)(755)))(752(804(112)(198))(208(592)(593)))))(23(368(82)(61(107)(756(603)(49))))(418))))))(822(294)(495(158(214(764(626)(426(327(657(29)(219))(668(153)(885)))(619(985(693)(923))(976(216)(261)))))(778))(932))(415(50(224)(348(688(384(893(99)(249))(188))(513(739)(173(870)(919))))(352(83)(693(815)(896(354)(706))))))(137(283)(247))))))) +(386(254(927(22)(509(232(22(538)(664(938(400(493)(687))(410(971)(401)))(12(736(513)(770))(11))))(365(24(162)(127(784)(214(340)(447))))(118(163(637(140)(487))(626(437)(361)))(357(108(100)(391))(919(193)(400))))))(851)))(635(477(784(468(473(475)(436(594(668)(40))(445(615)(760))))(934(709(987(115)(59))(7(620)(234)))(76(425(122)(219))(661(945)(169)))))(275(854(286)(434(915(845)(111))(527(627)(491))))(639)))(32))(977(157(727(959)(923(912(702(636)(512))(537(811)(622)))(509(904(619)(831))(260))))(287(102(275(472(292)(395))(277(805)(264)))(979(869(595)(842))(315(827)(425))))(12(522)(377(942)(208(418)(232))))))(923(216(403)(849(533(768(467)(926))(847))(762(82)(316))))(349)))))(133(728(783)(70(924(975(995(983(285(623)(181))(288(284)(205)))(389(131(192)(115))(303)))(75(571(828(500)(307))(467(442)(846)))(183(103(44)(647))(419(204)(180)))))(287(656(394)(990(584(693)(759))(108)))(616(883(31(854)(323))(633(589)(887)))(706(223(586)(474))(404)))))(767(472(851)(351(270(970)(82(548)(128)))(347)))(242(588(58(961)(30))(275))(737(437)(101))))))(55(266(252)(149(36(9(262(861(8)(350))(910(337)(513)))(660(900(338)(740))(291(31)(269))))(744(704)(502(842(740)(110))(193(608)(975)))))(465)))(933)))) +(437(610(409(875)(468(741(136(542)(641(978(972)(426(664(906(465)(739))(550(261)(104)))(869(712(274)(550))(600))))(256(360(910(406)(724(30)(686)))(204(673(684)(467))(35(156)(397))))(807(417)(200)))))(866(793(351(891(403(332(681)(146))(708))(679(581(501)(2))(620(9)(389))))(841(854)(533(49(300)(226))(56))))(560))(416(879(387(824)(646))(417))(728(829)(291(887(349(965)(549))(628(226)(903)))(660(76)(108(595)(26))))))))(869(484(813(138(197(497(723(641)(739))(382(670)(363)))(806(968)(260(876)(867))))(71))(259(289)(578)))(423(90(683(816(171(545)(8))(264))(134(832(310)(539))(822)))(981(621(343(431)(78))(512))(341(145(862)(487))(683))))(670(429)(461(672(27(55)(393))(263(464)(654)))(986)))))(587(103(203(68(521(39(183)(954))(779))(331))(360))(895))(145)))))(883(420(581(639(522(73(225(103(925(622)(543))(398))(771(37(469)(20))(472(215)(532))))(891(187)(640(321(387)(69))(183(881)(396)))))(833))(572))(241(918(770)(411(912(516(14(205)(586))(919(541)(543)))(420(711(813)(314))(478(747)(773))))(322)))(601(193)(740))))(531))(550(809(942(38)(608(699)(827(114)(502(937(84(725)(31))(831(275)(531)))(836(614)(350(926)(28)))))))(488(911(868)(439(53)(323(151(970(331)(29))(13(82)(708)))(198))))(489(64(489(788(202(841)(924))(564))(600))(759(515(397(941)(945))(416(419)(784)))(11(253(173)(933))(51(604)(140)))))(657(248(277(40(243)(240))(48))(696))(445(493(177(646)(120))(764(59)(261)))(590(60(733)(385))(673)))))))(518(873)(289(353(294)(939))(643(515(461(702(164(910)(857))(777(131)(576)))(299))(345(457(349(876)(544))(607(873)(413)))(330(820(875)(248))(240(185)(874)))))(959(189(164(324(304)(413))(845(154)(698)))(462(513(776)(97))(566(152)(256))))(153))))))))(331(26(671(101(994(136)(145(680)(389(813(724(102(569)(85))(62(845)(127)))(315(286)(224)))(271(845(666(416)(789))(781))(18(936(464)(742))(242(76)(233)))))))(661(597(934(335(673(493)(501))(329))(761))(464(284(212)(993(190(643)(692))(393)))(853)))(869(608)(610))))(726(895(85(494)(961(865)(140(794(507)(683(487)(963)))(560))))(230))(542(570(140)(485))(952(301(100(559(621)(388(290)(283)))(471(213(967)(503))(304(341)(153))))(710(159(875(909)(213))(356(651)(726)))(226(474)(620(923)(209)))))(259(759)(96(411(399(68)(891))(340(150)(890)))(552(472)(429(27)(647)))))))))(594(885(42(513(634)(430(722(874(930(298)(493))(888(124)(509)))(134(483)(835(42)(227))))(158)))(900))(161(138(674(39(277)(919))(642(871(81(775)(601))(850))(994)))(909(552)(846(935)(655(628)(530(932)(787))))))(437(6(237)(892(363(352)(792(667)(17)))(754(243)(11(843)(764)))))(196))))(214(749(722(480(46(129(227(682)(361))(531(95)(701)))(684(880(779)(884))(826(137)(723))))(782(809(887(419)(727))(562(767)(316)))(177(660)(164(823)(889)))))(876(269(968(957(754)(220))(273(219)(139)))(158))(304(477(638(601)(727))(280))(686))))(896(232(267(836(139)(394))(580(653)(394)))(683))(662(223(857)(491))(270(380)(909(138)(85(553)(701)))))))(943(608(326(69)(437(114(562)(724(235)(946)))(786(629(624)(64))(918(148)(632)))))(867(600)(319(894)(118(66(508)(942))(753(43)(90))))))(142)))))(227(739(957(778(958(637(604)(521(323(681)(406(536)(283)))(911(789(798)(450))(195))))(359))(393(619(663(938)(113(69(270)(947))(665(657)(558))))(964(275(959(815)(724))(568))(225)))(845(247)(425(896)(367(917)(197(475)(139)))))))(817(215)(63(528(280(459)(873(158(593)(661))(862(12)(514))))(86(412)(183)))(680(125)(834(619(769)(382(899)(273)))(484(145(633)(989))(47)))))))(817(341(233(232(104)(563(938)(365(20(387)(134))(638(424)(450)))))(720(378)(593(807)(800(390)(91(915)(987))))))(673(536(696(180)(876(861)(963)))(509(103(409(61)(341))(639(931)(187)))(134(83(615)(933))(859))))(373(61(709(612(141)(118))(982))(902(913(747)(565))(755)))(193))))(524(132(754(78)(194(785(156)(481))(769(894(732)(25))(278(826)(480)))))(511(9(301(866)(987))(976))(433(781(433(216)(797))(925(670)(128)))(868(847)(299(468)(530))))))(712(468(482(15(38(818)(333))(629(857)(979)))(132(276)(685(563)(590))))(525))(918(44(261(180)(935(329)(892)))(263))(895))))))(64(366(892(954(932(660)(664))(825(98(163(330(23)(164))(160(126)(720)))(481(529(421)(959))(285)))(161)))(883(755(139(232(241(422)(536))(653(754)(643)))(980(417)(865)))(170(65(689(240)(962))(485))(784(964(339)(788))(15))))(444(766(894(729(234)(723))(55(544)(537)))(566(493(821)(677))(77(756)(32))))(584(682)(525(173)(16(913)(125)))))))(223(303(110)(481))(893)))(67))))) +(414(317(558(596(895)(972(651(698(229(857(482(170)(799))(929(77)(890)))(368(487)(324(812)(731))))(50))(312(98)(513(678(275)(171(430)(943)))(771(685(238)(843))(29(360)(759))))))(900(511(452)(536))(15(998(352(183(828)(415))(391(488)(705)))(586))(119(793(701)(81(408)(793)))(887(614(511)(456))(441(867)(910))))))))(458))(269(641)(181(158)(956))))(526(636(343(943)(105(786(324(650)(775(780(200(819)(818))(641(389)(246)))(561(221(148)(695))(358))))(740))(98(783)(89(495(705(630(869)(426))(734))(221(731(178)(968))(623(565)(233))))(569)))))(397(787(317(462(29(57(698)(752(669)(105)))(166(14(384)(612))(714(586)(717))))(227(452)(656(504(100)(222))(191))))(271))(975(930(686)(353(784(453(288)(214))(598))(725)))(779(294)(450(264(682(360)(36))(563(867)(578)))(998(836(99)(542))(499(52)(342)))))))(624(866(501(51(58)(916(908(341)(833))(165(139)(333))))(503(278)(646(787)(668(664)(783)))))(380(643(949(529(350)(390))(753))(94(992)(151)))(181(269(301)(755(683)(307)))(719(235(710)(677))(88(345)(168))))))(735(780(245(454(701(220)(299))(520(332)(732)))(114(530(11)(477))(754(208)(652))))(469))(226(742)(169))))))(490(202(971(770(338(538)(256(195)(757(740(282)(152))(226(796)(423)))))(462(437(368)(875(243)(8)))(275)))(594))(246(152)(684)))(148)))) +(226(770(234(350(271(866(603(770)(728))(62(659)(52)))(425(685(836)(716))(515)))(965(414)(914(192(628)(92))(279))))(937(993(268(13(81)(958))(169(878)(203)))(169(911(711)(4))(370(58)(352))))(517(494(283(988)(9))(785(680)(379)))(725(298(639)(416))(50(265)(167))))))(757(921(180(97)(690(717(984)(312))(877(248)(964))))(213))(37(671(376(391(845)(557))(468(201)(491)))(392(592(31)(565))(544(171)(569))))(228(246)(799(106)(149(885)(290)))))))(181(849(630)(959))(361(824)(307)))) +(174(201(356(540)(797(158(446(853)(734(573)(265)))(326))(288(205)(579(261(162)(623))(382)))))(814(343)(862(841)(681))))(554(169(416)(3(417(144(260(317)(916))(70(791)(109)))(272(128(333)(414))(755(634)(697))))(556(75(438(809)(857))(164(550)(576)))(298))))(330(753(137)(300(294(343)(896(959)(706)))(818(32(386)(80))(202(95)(785)))))(497(407(822(318(344)(197))(319(777)(113)))(836))(989(703(691)(164(165)(498)))(175)))))) +(396(724(264(500)(455))(328(15(925)(274(524(427)(509(164)(400)))(380(845(545)(369(845(278(184(37)(850))(769(552)(647)))(729))(96(191)(573(803(970)(526))(21(295)(844))))))(484(239(28(979(557(805)(153))(951))(646(358(50)(890))(374(522)(289))))(478))(755)))))(376(615(589)(799))(811(93(51(815(83(836(958)(376))(455(197(975)(653))(367(654)(945))))(968(399(347(94)(187))(567(12)(809)))(515)))(72))(281(839)(449)))(857(583(135(93(183)(589(625)(617)))(538(847(940(191)(619))(726(240)(167)))(67(667(650)(944))(839(750)(238)))))(9))(463(912)(104)))))))(427(490(126)(405))(27(579(454(260)(550(395(878)(278(811)(311(97(14)(257(342)(399)))(478(213(763)(510))(927)))))(749)))(820))(744(864)(159(932(266(123(743(753)(491(481(725)(472))(830(564)(241))))(133(133(116)(453))(312(627(299)(190))(114(813)(347)))))(662(773(853)(440(688(297)(268))(511(137)(795))))(779(373(816(705)(702))(924))(713(738(436)(303))(28)))))(57(782(367(726(528(347)(357))(281(746)(892)))(87))(548(673(18(544)(41))(766(489)(496)))(935)))(792(417(34)(77(228(640)(148))(634(811)(990))))(184))))(83(682)(46(520)(914)))))))) +(812(323(627(316(479(971(438(688)(333))(422))(646))(914))(102(662(772(43)(681(862(35)(729))(830(24)(926))))(509(38)(844(833(627)(80))(655(803)(389)))))(327)))(178(678(626)(182(176)(294(484(346)(161(814)(308)))(824))))(814(310)(226(800(76)(785))(62(649)(946))))))(210(144(274(179(932)(437(754(242(78)(154))(250))(838)))(306))(309(289(895(916(850(962)(971))(452))(512(132(64)(845))(780)))(374(85(761(428)(223))(804(425)(339)))(523(912(690)(733))(441(112)(833)))))(463(408(318(807(334)(162))(911(256)(841)))(529(607)(334(116)(13))))(239))))(203(161(534)(602))(353)))) +(529(760(402(704(675(10(513(363(340(934(195(916)(190))(369(989)(160)))(65(725(236)(49))(404(454)(220))))(933))(205(727(481(580)(191(285)(120)))(47(607(151)(619))(661(821)(740))))(551(463(635)(380(267)(667)))(676(395(496)(510))(91(495)(824))))))(803(445)(675(773(217)(173(331(823)(234))(20(311)(289))))(951))))(682(901)(504(415(677)(679(985)(38)))(380(331(294)(371))(23)))))(752(341(66)(6(413(854(585(691(853)(295))(343(494)(831)))(997(359(156)(114))(137)))(923(116)(733)))(389(723(815)(956(498(933)(659))(406(167)(199))))(771(180(96(673)(701))(667))(857)))))(615(609(993(822(594)(450(606(208)(422))(564(866)(486))))(447(193(196(582)(765))(840(842)(614)))(615)))(899(595)(67)))(661(285(98(718)(726(414)(509(630)(184))))(164(619)(710)))(390)))))(342(468(60(437)(15(233(843(863(980)(324))(982(649(947)(683))(593(601)(330))))(269))(838(759(968(750(841)(653))(435(727)(913)))(241(94)(670)))(555))))(936(718(573(925(734)(537))(542(228(424(387)(315))(426(795)(781)))(67)))(680))(933(107(472(355(218(193)(270))(623(394)(818)))(181))(701(870(542(111)(554))(419))(310(933(726)(117))(255))))(123(813(749(352(404)(990))(766(113)(7)))(5))(825)))))(545)))(616(338(541(34(916(172(382)(921(114)(773)))(704(448)(980(927)(108(737(367)(28))(608)))))(865(591)(499(949(592(431)(765))(20(309(726)(502))(712)))(148(173(257(159)(117))(135))(900)))))(874(628(960)(676(531(334(438(469)(846))(230(725)(585)))(735(53)(628)))(684(850(63)(950(673)(274)))(544(12)(988)))))(33)))(122))(343)))(52(226(251)(375(507(538)(940))(608(315(400)(300(460)(782(802(148(779(358)(959))(829(333)(525)))(429(921(686)(402))(146)))(678))))(659))))(99(669(111(66(742)(777(944(343(411(683(839)(322))(118))(684))(838(311(352(50)(362))(634(573)(323)))(775(4(654)(233))(162(449)(909)))))(528(130(110(469)(116(923)(663)))(524(958(887)(814))(654(69)(59))))(903(310(138(290)(752))(100(508)(513)))(950(678(19)(512))(898(908)(968)))))))(56(730(756(786(46)(827))(775(28)(772(836)(607(883)(120)))))(438(821)(612(258(247(539)(771))(318(581)(427)))(159(483(159)(66))(304(791)(807))))))(397(211(496)(444(342(237(816)(723))(995))(508(822)(549(275)(604)))))(252(515(718)(525))(898(630)(992(378)(701(451)(738))))))))(197(92(243(214(743)(72(32)(309(205(94)(778))(774(508)(252)))))(50(197(789)(261(918(894)(916))(761(138)(820))))(107)))(477))(463(499(213(452(805(158)(885(120)(892)))(990(860(336)(760))(352(818)(734))))(546(729)(813(621(707)(441))(661(36)(827)))))(658))(705(787)(623(51(386(360(800)(253))(502))(702(912(386)(632))(170(648)(869))))(195(426)(804(434)(446))))))))(684)))) +(212(454(677(225(655(101(997(203)(529))(976(769)(58)))(800(500(517)(747))(665)))(874))(581(189)(215(89(838(367)(820))(614(107)(320)))(475(399(110)(997))(223)))))(245(855)(869(885(813)(388(243(338)(188))(221(898)(482))))(7))))(153(228(330(448(181(26(287)(246))(855(193)(404)))(472))(146))(41(696(432)(798))(514(235(779)(884(71)(503)))(941(509(575)(216))(521(827)(234))))))(649(937)(778)))) +(629(269(370(416)(444))(951(570)(665(782(695(691(931)(813))(315))(60(616)(12(181(945(261)(669))(525(487)(907)))(983(75)(503(592)(360))))))(501))))(310(186(101(736(472(857(451)(842(473(429)(420))(255(348)(309))))(783(356(881(598)(22))(884(504)(125)))(64(94)(525))))(905))(314(286)(696)))(3(454(85(2(292(126(568)(172))(833))(515(881(360)(773))(694(276)(91))))(387(896(266(610)(815))(726))(507)))(352(865)(244)))(106(146(829)(419(130)(393(249)(278(736)(294)))))(716))))(206(53(604(693(635(646(690(759)(493))(27))(980))(376(770(790)(277))(936(829(971)(234))(946(82)(374)))))(351))(678(204)(423(215)(963(11(13(602)(734))(305(196)(671)))(442(317(340)(705))(173))))))(393(32(174(436)(334))(536(147)(324)))(991))))) +(366(957(843(140(214(755)(408(487)(162(452(225(281(863)(484(68)(68)))(309))(428(59(752(29)(49))(786(515)(321)))(78)))(882(125(279)(983(141)(503(129)(777))))(688)))))(939))(148(869(249(302(563)(28(597(505)(616(597)(685)))(215)))(382(553(790(416(950)(433(507)(276)))(28(798(905)(20))(789(934)(213))))(889(888(623(13)(47))(838(861)(296)))(604(544(382)(580))(18(371)(605)))))(572(380(602(37(955)(885))(720))(452(232(275)(1))(999(383)(338))))(100(724(617(900)(719))(658(560)(790)))(632(750)(98))))))(886(691(96)(504(112(453(611(124)(792))(620(850)(228)))(313(128(230)(326))(195)))(50(853)(41(459(856)(317))(4)))))(380)))(955(790(670(706(37(725(635)(336(690)(909)))(215))(983(977(258)(865(438)(688)))(414(206(921)(850))(77(384)(913)))))(973(700(202(395(908)(308))(266(836)(326)))(909(11)(873(986)(262))))(797(421(968(794)(755))(235(13)(53)))(336(195(938)(140))(637(257)(609))))))(979))(379(144)(445(825)(128(710(990(606(896)(992))(238(845)(804)))(942(547(901)(911))(913(865)(26))))(25(728)(603))))))))(33(880)(5(597(277)(347))(240(374(119(609(69(496)(354(5(689)(927))(553(2)(902))))(743(711)(929(792)(897(560)(348)))))(570(48(434(107(519)(310))(182))(704(621(759)(64))(841)))(204(448)(525))))(618(645)(877)))(468(852)(527))))))(629(75(638(587(475(847)(337(861)(157(769)(31(28)(900)))))(161(780(299(700(189(566)(779(517)(536)))(517))(893(784(2(25)(277))(548))(519(388)(318(441)(185)))))(813(197)(503(577(597(806)(341))(240))(354))))(540(857)(444))))(863))(837(719(189)(796(778(401(79(663(492(947)(970))(575(586)(577)))(52(592(352)(46))(160)))(416(274(898(448)(846))(983(73)(381)))(90(874)(924(254)(244)))))(402(925)(295(149)(537(195(632)(820))(25(151)(734))))))(614(299(449(431)(534(787(548)(262))(821(622)(657))))(711))(478(564(988)(44(752(65)(969))(245(769)(390))))(705(613(596)(941))(326))))))(128(647(353(303(587)(212(556(674)(276))(657(67(405)(496))(886))))(917(544)(723(531(794(97)(337))(587))(879(532(858)(257))(381(567)(612))))))(6(386(599(323(772)(287(449)(323)))(642))(73(463(222(813)(637))(14(880)(303)))(19(458(231)(527))(612(638)(799)))))(389)))(182(291(132(352(700(170)(496))(158(931)(489(788)(104))))(312(7)(843)))(279))(654(397(729(6)(188(459(187)(646))(851(963)(328))))(488(614(117)(668))(243(259(999)(468))(779(198)(752)))))(670(553(445(392(191)(557))(207(119)(96)))(181))(190(767(898(1)(588))(504))(462(661(546)(40))(593(49)(876))))))))))(92(629(253(115)(327(441(737(778(393(865(387)(977))(663(468)(881)))(123(170(273)(117))(55(89)(2))))(469(912(869(676)(960))(290(21)(139)))(817)))(257(5)(484(978)(707(896(74)(967))(902)))))(136(603(381(691(230(108)(293))(497(2)(302)))(186(198(184)(901))(788)))(344(429(798)(80(626)(45)))(254)))(206(33)(18(547(293)(733(555)(834)))(70(509)(352)))))))(80))(283(851)(366(412(26(118(67(946(883)(510(303)(716)))(474))(746))(156(610(67(749(524)(376))(801(246)(982)))(919(626)(630(829)(396))))(858(612(157(285)(201))(868))(579))))(955(467)(974(296(545)(587))(451(594(99(483)(313))(359(323)(228)))(375(150(69)(958))(388(660)(995)))))))(372(785)(496(684(207(791)(196))(93(156(803)(649(706)(323)))(573(902(558)(742))(824(829)(775)))))(235(659(57(222(519)(237))(952(682)(329)))(487(929)(805)))(95(115(18)(518))(985(403)(793))))))))))) +(365(425(1(856)(393))(741(830)(219(688)(615(33(619)(964(346(686(668)(209))(223))(256(928(94(799(619)(18))(48))(114))(110(393(722)(557))(628(609(476)(582))(158))))))(308(755(419)(160(389(653(673(126)(340))(264))(561(185)(861(231)(726))))(674(771(648(642)(483))(569))(628(502(822)(625))(916(168)(596))))))(733))))))(364(49(346(165(938(721)(951(618)(741(323(244(285(532)(936))(647(422)(855)))(665(198(28)(352))(952(115)(922))))(721))))(608(779)(856(193(681)(794))(629(635)(506(342)(953(179(399)(189))(617)))))))(94))(739))(884(604)(581(49(189)(653(576(734(415)(682))(291(52(494(798(401)(928))(613(181)(151)))(956(807(119)(992))(151(458)(580))))(293(877(986(725)(342))(47))(701(300(809)(477))(63)))))(250(300(671(73(431(866)(323))(563(480)(79)))(384(291(881)(609))(24(736)(946))))(60(52(560)(222))(921(834(570)(807))(579(944)(394)))))(934))))(775(972(919(23(95(852(874)(305(457)(808)))(589))(324(122)(991(990)(324))))(618(814)(551(442(364(868)(963))(531(36)(475)))(551(176(276)(496))(802(749)(115))))))(939(531)(686(779(466(733(708)(15))(167(26)(582)))(742))(227(698(795)(224(73)(198)))(484(364(36)(286))(510(466)(548)))))))(251)))))) +(963(87(648(755(191)(334(790(853)(584(434)(84(13(549(699)(53))(429))(871))))(71)))(51(823)(977(2(252(316(345(142)(594(198)(697)))(934(992(916)(817))(600(337)(603))))(867))(344))(262(914(241(32(52(95)(174))(381(384)(158)))(110))(733(200(273)(211))(844(536(625)(167))(293(61)(283)))))(808(189(617(742(924)(812))(508(217)(394)))(100))(908(330)(754(499)(585(354)(129)))))))))(461(950)(520)))(261(831(276(290(641)(101(343(566(278)(367(618(47)(595))(358(328)(537))))(149(684)(612(805)(769(816)(578)))))(280(258(825(926(879)(606))(193))(564))(71(630(293(732)(946))(712(473)(625)))(374(67(218)(854))(895(862)(220)))))))(957))(861))(661(64(880(162(868)(654(251(465)(650(708(567)(669))(480(629)(825))))(734)))(743(413)(776(282(374(680(629)(384))(651(574)(174)))(357(835)(514(434)(570))))(904(994(219(989)(679))(977(539)(365)))(804(255(405)(986))(76(170)(185)))))))(457(230(341)(892(678(70(654(201)(978))(422))(502(312(773)(106))(857(770)(750))))(824(52(654(397)(186))(862(907)(82)))(960(239)(298(551)(854))))))(116)))(352(929(110(132(637)(12))(114))(565(540(413)(314))(39(287(826(757)(642))(398(916(351)(451))(925(909)(727))))(521(751(437(18)(293))(611))(23(665(487)(873))(609))))))(603))))) +(991(212(432(0(746)(924))(617(505)(327(629)(597(321)(836)))))(389(984(521)(38))(514)))(310(341(782)(246(222(564(951(759(323(682)(259))(532(407(680)(494))(754)))(83(634(232(70)(72))(515(588)(644)))(968(267(985)(86))(239(335)(637)))))(437))(751(53(581)(353(191(675(402)(120))(189))(787(559(285)(474))(765))))(126(168)(235(777)(264(685)(968))))))(39)))(804(817(424(512(887)(134(603(807(360(348)(254))(468(10)(352)))(829))(445(471(447(45)(637))(669))(720(938(560)(221))(510(609)(510))))))(204))(706(528(498)(769(667(915)(36(332(635)(584))(626(599)(888))))(690(287)(173(412(571)(630))(273(434)(874))))))(775)))(354(269(109(379(258(542(754(774)(853))(537))(502))(713(582)(605(662(755)(36))(575(172)(227)))))(292))(147))(130))))) +(507(30(140(749(204)(234(249(554(539(836)(9(663)(437)))(722))(768(160(624(127)(783))(865(41)(793)))(310(742)(694))))(153(715(887(272)(525(627)(399)))(612(627(65)(560))(680)))(237))))(378(222(49(196(434)(118(675(755)(719))(498)))(401(105(363(19)(548))(569(352)(715)))(657)))(378(957(613(395)(518(133)(545)))(967(570)(607(961)(245))))(530(625)(75(76)(901)))))(174)))(762(847(530(373)(55(480(32(554)(387))(161))(563)))(501(3)(109(769(251)(323))(833))))(152(928(233(535(161(838(913)(61))(816))(673(375)(131(451)(543))))(121))(10))(827))))(989(850(965(986)(894))(674))(157(71(400(659(794(17(703(544)(549))(732(707)(499)))(529(939(253)(588))(986(920)(589))))(146(317)(939)))(364(881)(801)))(919(589)(344(827(329(206(812)(910))(238(627)(182)))(488))(113(867(813(457)(886))(74))(352(447)(246(590)(707)))))))(148)))) +(494(696(54(206(236(544(467)(226))(932(327(332(425)(940))(751))(463(571)(768(860(652)(778))(423(87)(479))))))(916(850)(271)))(404(929(457(922)(187(394(176)(46(899)(232)))(208(753(644)(718))(746))))(841))(789(659(902(481(964)(767(273)(745)))(988(808)(188(529)(545))))(656))(545(953)(512(638(273)(200(915)(751)))(960(255(752)(880))(794(593)(953))))))))(250(534(470(889(676)(268(654(520(730)(156))(506))(721(991(574)(253))(495(93)(766)))))(132(282(138(973(731)(1))(795(312)(496)))(292(371(909)(322))(423)))(54(789)(388))))(730(343(332(395)(694(586(468)(344))(282(335)(64))))(427(515(500)(221(958)(465)))(597)))(427)))(554(581(59)(569(50)(88)))(359))))(839(328(939(877(699(624(810(551(635)(239))(914(691)(577)))(933))(710(225(187)(353))(23(352(375)(186))(731(1)(277)))))(735(917(439(619(979)(311))(820(210)(117)))(484))(425)))(239(593(210(986(716)(381(860)(732)))(741(3(661)(971))(968)))(526(264(532(364)(340))(740))(324)))(202(272(125(388(418)(162))(333))(130(12(428)(185))(284)))(0(219(632)(812))(632)))))(808))(662(13)(410(443)(375(635(816(757(769(636)(739))(629(988)(248)))(476))(719(224)(728(329)(386(706)(693)))))(181(366)(595))))))) +(420(450(527(243(482)(130(199)(34(648(718(993)(215(748)(563)))(290))(303(698(917(854)(324))(966(37)(947)))(471)))))(552))(487(216(910(604(465)(982(813(831)(788(115)(31)))(572(470(43)(315))(330(991)(688)))))(635(974)(389)))(910))(439(640(836(95(130(410(757)(649))(229(659)(705)))(675(477(505)(424))(752(130)(509))))(26))(691))(718(7(58(953)(840(530(594)(301))(243(955)(791))))(77))(55)))))(682(380(558(469(455(449(205)(757))(164))(439(358(104(781(962)(717))(938(624)(758)))(102))(778(841(607)(972(880)(945)))(156(948)(841(541)(423))))))(631))(241(346)(958(741(917)(949(97)(813(627(72)(872))(297(287)(312)))))(17(87(780)(636(515)(139(820)(616))))(890(921(246)(343))(111(599)(850)))))))(983(322(398(608)(801(479(700(448)(488(958)(783)))(30(334)(895)))(104(2)(620(333(722)(524))(470(73)(312))))))(402(860(82)(62(805)(158(286)(23(217)(376)))))(1(566)(976(254(112(77)(834))(75(626)(307)))(763(226(484)(362))(328(566)(758)))))))(406)))) +(443(975(318(463(260)(832))(968(854)(292(691(177(32)(79))(959(580)(51(293)(155))))(890))))(723(209(659(95(266)(684(903)(635(684)(170))))(403))(697(626(731(944(550)(454))(466(83)(755)))(272(455(879)(596))(752)))(377(492(973(823)(302))(173))(699(748)(776(48)(215))))))(443(812)(485(34)(120(456(633(357)(818))(777(500)(912)))(811))))))(144(595(370(489(847(151(607(959)(938))(364))(783))(680(228(339(983)(734))(554))(815(445)(798(669)(544)))))(146(830)(601)))(746))(553(279(72(742)(79(225(58)(146(672)(450)))(212(127(511)(916))(34(561)(148)))))(172(306(258)(8(532(374)(524))(951(381)(269))))(284(408(267)(821(129)(692)))(177(848(10)(944))(885(855)(510))))))(783(807)(271))))) +(455(339(734(839)(929(695(655(650(560)(829))(600(92)(660)))(997(442(697)(627))(664(471)(557))))(474(823(208(344)(744))(471(209)(566)))(947(999)(581(614)(767))))))(839(536(747)(881))(460(524)(252(829)(278)))))(228(853(925)(288(203(216(960(443)(160))(55))(993(385(170)(251))(419(390)(434))))(964)))(802(512)(956)))) +(73(767(422(408(82(896)(362(23)(82(839(488(228(339)(739))(891(977)(483)))(487(531(817)(36))(584(20)(773))))(437(89(372)(765(166)(72)))(376(824(195)(867))(397(225)(785)))))))(651(626(375(30(27(563)(960))(194))(92(937)(42(491(921)(302))(775(998)(930)))))(565(419)(441(992)(751(292)(517(436)(769))))))(807)))(1))(900(806)(189(650(16)(863(22)(339(845(46)(67(52)(389(641)(411))))(153(362(461(524)(310))(207(465)(275)))(311(17)(974(857)(716)))))))(683(618(381)(749(598(979(604(556)(698))(352(394)(913)))(36))(195)))(140)))))(478(532(738(352)(522(209)(627(837(624)(81(869(508(149)(313))(449(953)(683)))(40(833)(575(89)(307)))))(798(406(784(278)(671(275)(458)))(989))(644)))))(58(252(86(930(739(357)(846(626)(334)))(672(550)(754(796(868)(41))(316(331)(324)))))(164(148(310(169)(913))(804(824(859)(920))(243(67)(735))))(876(381(344(354)(15))(571(877)(29)))(419(282)(135(490)(581))))))(530(251(410(175(892(989)(834))(593(558)(235)))(811))(52(226)(511(646(443)(706))(704(217)(968)))))(984(443)(923(792(129(60)(420))(194(705)(291)))(409)))))(803(209(21(604(494(53(232)(704))(924(338)(746)))(891(87(133)(384))(669(195)(358))))(550(853(291(482)(815))(755(740)(7)))(490(104(201)(466))(303))))(602))(779(557)(86(677(524(636(579)(84))(96(173)(520)))(109))(168))))))(591(556(598(27)(457))(851))(542)))) +(65(232(525(329(183(74)(953(331(995(8)(128))(257(699(151)(934))(705)))(878(622(758)(327(246)(101)))(680))))(9(12(776)(174))(77(541(432(604(363)(98))(615))(586(266)(390(30)(372))))(785))))(199(20(593(884(271)(589))(609(519)(516(300(328)(211))(307(263)(359)))))(203(947(838)(42))(828(517(407)(485(886)(849)))(666(464(353)(684))(644(995)(720))))))(845)))(386(85(512(245(724(405(348(552)(382))(913))(669))(571))(834(781(185)(836))(843(909(36(65)(610))(142(505)(838)))(214(697(573)(881))(720)))))(507(553(159)(258))(847(122)(840(115(868(206)(662))(17(771)(982)))(572(290(24)(746))(666(783)(986)))))))(405)))(45(87(707(530(711(613(585)(947(823(635)(742))(315(82)(988))))(291(495)(433(749(570)(474))(592(823)(432)))))(712(629)(419(338(114(965)(419))(107(19)(335)))(674(720(910)(769))(25(210)(569))))))(711(78)(498(715)(674))))(721(187)(942(965(621)(433(57)(772)))(345))))(566(848(192(160(483)(390))(870(596(42(120)(366(485)(275)))(235(963(446)(869))(62(37)(354))))(603(457(678)(745(947)(28)))(614(495)(681(766)(588))))))(138))(617)))) +(475(409(68(109(84)(634(702(945(49)(477))(147))(287)))(356))(994(313(788)(151))(32(594(420(384(938)(491))(831(52)(196)))(338(402)(281)))(290(286(294(364)(927))(603(797)(200)))(348)))))(675(497(397(726(127)(444(891(993)(623))(327)))(586(8(118(300)(946))(716))(952)))(567))(326(805(989(391)(796(319)(436)))(747(802(189(416)(594))(772(951)(952)))(282(14)(97(830)(415)))))(977)))) +(131(145(274(990)(612))(201(139(655)(119(730(229)(803(80(312(811(374(959)(863))(180(867)(703)))(46(385)(79(181)(218))))(188(223)(956(487)(435))))(327)))(661)))(316(883(534)(315(803(248(251(84(788)(945(978)(483)))(309(321(656)(3))(49(464)(40))))(438(810(9(688)(994))(340(718)(852)))(28(175(949)(455))(559(609)(367)))))(225(828)(294)))(798(424(69(453(84(526)(852))(577))(811))(620))(789(560)(511(81)(324))))))(500(832(378(537(3)(156(942(768(149)(699))(286(917)(914)))(763)))(823(716(381(322(812)(237))(586(618)(644)))(222(479(446)(293))(306)))(850(379(563(383)(519))(371(752)(934)))(76))))(13(480(91(107(431(576)(52))(515(99)(812)))(237(68)(671(891)(809))))(69(255)(504)))(501(764(790)(687(246)(2(66)(306))))(682(560(31)(174(860)(794)))(922(533(593)(294))(870))))))(98(239)(857(491(684)(788(254(723(704)(180))(212))(167)))(54(404)(404(599(127(980)(956))(56))(801(569(267)(733))(841(871)(272)))))))))))(265(823(681)(373(261(54(471)(635(463(506(941)(860(184)(431)))(851))(435(741(26(790(871)(733))(944(526)(498)))(938))(1(211(92(981)(690))(534(499)(975)))(279(987)(129(195)(434)))))))(139))(587)))(608(72)(45(716(229(30(347)(773(265)(539(602)(912))))(455(907(859)(775(56(270(805)(884))(523(45)(342)))(219(215)(194))))(186(821(828)(978(555(971)(116))(106(575)(597))))(295))))(107(792)(237(451(219(517(252(114)(963))(374))(535(85(726)(941))(366)))(758(61(25(923)(539))(28))(76)))(843(382(584(813(123)(105))(712(953)(328)))(798(108(186)(828))(917)))(255)))))(418))))) +(642(524(376(111(612)(962(336(157(56(738)(252(164(990)(656(271)(12)))(262(406(250)(455))(478(42)(537)))))(822(408(51(318)(392(48)(402)))(995))(270(524(975(727)(246))(437))(86(369(747)(755))(909(697)(685))))))(982(492(787(914(671(617)(327))(512(365)(814)))(412))(534))(467)))(32(187)(103(343(605(727(330)(559(266)(489)))(889(901(248)(945))(212(393)(474))))(256))(361)))))(470(629)(738(786(518)(724(233(779(711(854(444)(615))(768))(765(607)(7)))(253))(220(979(350(21)(501(949)(739)))(662))(949(620(700(767)(294))(972(28)(892)))(784)))))(376(729(695)(476(683)(540(410)(646))))(142(398(241)(877(77)(539)))(133(930)(821(222(84)(554(120)(433)))(573))))))))(352(538(789(466(254(834)(778(295(698(428(103)(234))(736(107)(546)))(270))(47(262)(599(6(791)(409))(879(191)(795))))))(770))(830(172(671(405)(416(897(174(122)(680))(23(971)(498)))(702(422(17)(297))(44(368)(130)))))(918(540(154(576(86)(505))(397(116)(311)))(727(393(17)(25))(769(187)(675))))(311(222(381)(850(308)(584)))(396(557(609)(786))(471)))))(325)))(908(156)(506(640(283(270)(321(462(958(85)(914))(323))(978(502(59)(218))(971))))(614(626)(850(466(794(228)(720))(636(81)(636)))(657(628)(115)))))(173))))(851(127(444(242)(631(854)(803)))(458(956(354(217(377(363(688)(183))(745(722)(828)))(408))(831))(584(410(567(737(557)(575))(110(93)(779)))(143(620(853)(381))(505(313)(870))))(266)))(821)))(751(183(206(990(352(550)(926(883)(15(750)(654))))(336(869)(572)))(121(146(714(385(380)(320))(253))(578(671)(350(481)(50))))(849(555)(973))))(752))(478(587(951(117(521(175(525)(117))(929(64)(905)))(206(49)(611(312)(487))))(560(248(222)(543(880)(379)))(120(758(168)(492))(903(145)(161)))))(539))(789))))))(14(99(473)(822(49(960(325(628(511(515(738)(88))(49(765(549)(395))(932)))(227(565)(278(897(538)(991))(482(601)(112)))))(115(916(231(281(427)(360))(238(138)(172)))(797(83(422)(646))(680(365)(50))))(294)))(648))(64(7(52(684)(369(356(991(59)(748))(589))(924)))(24(401(293(470(417)(580))(435(640)(516)))(243(412)(222)))(342(849(557(962)(552))(89(707)(667)))(528(942(953)(49))(568)))))(143)))(222(564(438)(0))(352(947(593(508(73(712)(947))(422(445)(361(297)(141))))(180))(770(83(263(770(175)(137))(302))(849(102(115)(415))(688(553)(476))))(666(931(218)(60(411)(711)))(784))))(776)))))(694(519(226(181(19)(394(803(576(6)(284(915(177)(127))(326(132)(146))))(166(972)(996)))(437(920(652)(530))(397(38)(473)))))(324(683(726)(524(605)(1(866(967(955)(6))(21(278)(638)))(551(348(604)(628))(926(857)(758))))))(113)))(113(36(367(371)(810(859(312(908(95)(410))(892(248)(630)))(660(476(286)(727))(463)))(860(979(93)(358(10)(186)))(746(608(152)(391))(382(742)(606))))))(618))(85)))(387(861(385(498(101(91(949)(820))(728))(568(502(99)(723(322(530)(223))(698(610)(944))))(286(11(955(795)(607))(68(227)(138)))(520(786(945)(652))(944(174)(290))))))(984(954)(712)))(753))(826(632)(990)))))) +(856(996(876(525)(973(564(607)(316(599)(529)))(622)))(786(486(674(358(719(429)(742))(261))(161(73(586)(841))(772(653)(408))))(586(786(695)(126(280)(629)))(388(14(665)(143))(85(945)(797)))))(592)))(910(208(767(404(290)(386(813(29)(174))(849(265)(424))))(864))(432(381(689(684(299)(846))(205(911)(111)))(702(524(484)(236))(142(156)(705))))(985(63(450(144)(31))(841))(205(706)(597(685)(768))))))(862(332(227(563)(531(446)(844(191)(406))))(509))(992(560(921)(644(418)(519(178)(64))))(84))))) +(176(101(948(912)(486))(928(57(356)(199(755)(211(569(605(596(954)(618(319)(393)))(146))(890(855(688(129)(106))(982))(46)))(828(549(717(775)(460(58)(452)))(370))(708(506(313(442)(200))(521(62)(352)))(149))))))(64(150(4)(96))(944(30(619(77(587(701)(11(478)(837)))(984(547(148)(696))(773(262)(270))))(668))(802(166)(789(148(721(917)(265))(20(330)(271)))(155(608)(29(109)(950))))))(848(530(11(620(288(440)(906))(18(692)(294)))(296(335(256)(353))(499)))(872))(949))))))(819(68(181(382(370(295(681)(117(662(946(994)(184))(961(875)(933)))(221(242(919)(615))(197(155)(622)))))(587(718(490(708(555)(878))(635(316)(218)))(884))(231(280(186(96)(483))(828))(688(155(87)(185))(289(928)(929))))))(422))(968(809(918(289(663)(326))(453(20(518)(744))(96(267(972)(243))(239))))(738))(672(337(59(844(404)(403(572)(174)))(102))(675(832(699)(755(660)(825)))(345)))(401(226)(17)))))(25(120(102(301(260(830)(305(979(689)(549))(586(897)(364))))(579(177)(476(946(956)(947))(626(520)(711)))))(216))(692(457(731)(264))(372(846(4)(868(78(433)(303))(0(310)(211))))(311(790(151(876)(99))(181))(356(536(445)(745))(781))))))(919(736)(659(591(118(150(448(608)(362))(405))(991(485(84)(53))(964)))(611(758)(183(961(302)(811))(932(660)(977)))))(774(841)(995(332(10)(291))(963(387)(791(604)(888)))))))))(336(632(785(158)(771(554)(230(12)(510(528(812(803)(30))(504(577)(129)))(950(84)(521(626)(149)))))))(454))(226(380(215(777(654(50(965(970)(799))(556(859)(637)))(896(539(125)(419))(518(323)(687))))(504(59(674(743)(547))(490))(526(904(158)(916))(980(100)(389)))))(101(291(70(939(804)(239))(107(16)(310)))(914(364(583)(966))(333(593)(867))))(956)))(213(260)(568(407(697(761)(215(87)(576)))(598(467(555)(464))(940)))(137(613(562(256)(380))(973(194)(463)))(38(97(235)(534))(370(103)(831)))))))(779(877(268(508(434(316(812)(716))(631(905)(478)))(203))(700))(167(236)(524(846(117(676)(501))(402(71)(558)))(159(310(967)(491))(635(870)(178))))))(494(583)(54))))))) +(852(666(196(965(46(969)(50(560)(653(736(977(174)(799))(579(610)(187)))(535(224(319)(905))(659)))))(16))(823))(166(432(547(118(22(308)(222(604(187)(673))(810(780)(109))))(598(435(31)(945))(291(95(217)(110))(277(11)(311)))))(704(456(508(118(85)(886))(29))(614(497)(156(232)(940))))(768(756(268(535)(592))(302(651)(89)))(656(136(606)(255))(337)))))(5(615(988(615)(257))(289(279)(652)))(459(207(213(506(469)(919))(312(955)(974)))(210(94(775)(751))(114(374)(289))))(970))))(823(677(631)(111(23(70(252(833)(937))(96(627)(806)))(429))(849(810(700(99)(288))(809(712)(245)))(175))))(150(496(107)(967(247(953)(779(238)(795)))(707(186)(458(789)(128)))))(722(937)(694(205(529(73)(285))(608(130)(689)))(230(640(404)(451))(397(610)(485)))))))))(817(111(479)(493(640)(976)))(968(787(853(363)(810(352(620(800(398)(118))(63))(12))(35(515(828(570)(819))(866(586)(853)))(525(661(770)(93))(10(747)(545))))))(336(535(871(826)(918))(174(983)(152)))(551(175(758)(786(348(667)(264))(736(80)(377))))(471))))(338)))) +(159(588(648(580(809(334)(867))(720(992)(823(948(191(789)(447))(11(359)(278)))(932(524)(721(60)(137))))))(699(706(432)(424))(611(268(284)(505))(732))))(77(634)(587(495(920(97)(858(188(258)(356))(183(499)(877))))(374))(268(602)(266(32(176(989)(520))(615(969)(852)))(864(507)(112)))))))(141(659(312(679)(919(995)(909)))(188(274(613(941(33(898)(115))(664(417)(577)))(380(811(344)(209))(909(275)(408))))(103(817)(477)))(524)))(265(696(0(31)(444(296(920)(416(933)(798)))(235(869(622)(274))(401(169)(71)))))(611(515)(179)))(725(444)(536(990(419)(543(369)(498)))(141(984(858(914)(322))(340))(469(623)(285)))))))) +(336(864(658(181(900(275(751(471)(226(569)(643)))(648))(425(374(862(656(527(498(55)(653))(346(235)(476)))(438(714(588)(255))(411(829)(304))))(841(825)(327)))(210(639(586(677(84)(344))(593(334)(397)))(480))(555(30(7(941)(522))(320(862)(219)))(444(70(5)(734))(385)))))(7(553(547(466(45(793)(99))(982))(649))(244(382(782(140)(514))(664(584)(980)))(871(627)(457(816)(985)))))(705(612)(465)))))(859(44)(481(103(25)(283))(767(652)(772)))))(187(874(904)(407(225(368(745(743(32(334)(573))(337(243)(16)))(287))(380(80)(694)))(307(471(214(186(343)(653))(357(46)(263)))(845(250(20)(404))(814)))(492)))(318(602)(184(78(508(755(237)(697))(300))(12(269(860)(437))(35(952)(395))))(292(59)(173))))))(778(520)(61(146(876(761(700)(860))(525(179(275)(726(905)(322)))(438(198(574)(622))(228))))(858(365(670(485)(409(64)(234)))(213(582)(672)))(129)))(796(703(103)(49(599(219)(677(685)(280)))(210(881(922)(470))(38(421)(210)))))(266(95)(119)))))))(778(858(717)(534))(80(141(544(254(690(614(507(629)(10(300)(952)))(667(144(301)(209))(53)))(434(13(344(404)(324))(460(81)(926)))(711)))(875(51(112)(744))(875(164(686(561)(754))(866(448)(165)))(395(118(713)(700))(905(476)(590))))))(990(8(118(265(379)(543(7)(953)))(49(166(588)(695))(446)))(616(877(854(645)(206))(842(910)(94)))(9(440(734)(949))(873(555)(141)))))(532(934)(143))))(229(380)(642)))(568(820(462(665(264)(144))(840(671)(174)))(629))(731)))))(237(896(502(564(870)(392))(655(91)(821)))(448(51(63(690(471(562(296)(75(803(55)(176))(811)))(285))(837(105)(697(147)(32(984(270)(942))(180)))))(922))(922))(535(309)(421(420)(547(340(778(333(342(682)(773))(104))(684(410(822)(239))(851(768)(114))))(229(309(154(258)(459))(122))(88(661)(146(603)(508)))))(945(12(185)(792))(580(191)(396(399(728)(640))(496)))))))))(754(978(819)(263(522)(970(857(736(971)(961(126)(219(491(237)(736))(884(6)(52)))))(443(588)(973(328)(4(295)(922(5)(690))))))(466(464(223)(193))(665(940)(607(771(566(60)(804))(764(805)(19)))(31(826(212)(502))(735))))))))(335(216(662)(84(675)(410(987(823)(90))(768(625(375)(982(623(730)(312))(274)))(182)))))(375(892)(883)))))) +(577(685(6(618)(759(796)(450(498(2)(339(178)(280(991)(469))))(855(524)(759(916(197)(616))(787))))))(589(294)(184)))(930(157(636)(101(799)(349)))(703(983)(449(371(93)(739))(590(735(820(620)(972))(31))(523)))))) +(803(725(134(693(276(173(744)(147(680)(339)))(865(417(509(912)(113(923(505(82)(883))(176))(669)))(831))(922(388(330)(424(452(795(836)(21))(619(315)(562)))(104(455(168)(335))(569))))(697))))(722(896(266)(831(164(913(244(152(186)(342))(767(837)(285)))(764(655(924)(283))(707(306)(297))))(175(705(463)(177(871)(291)))(233(653)(60(706)(698)))))(601)))(339(615(626(368(682(485(608)(294))(638(458)(944)))(584(753)(754(690)(658))))(273(169)(548(205)(387))))(866))(999(620)(734(56)(269(139)(187)))))))(65))(418(8)(699(181)(343(846(769(306(78)(371(685(476)(573(435)(981)))(829)))(392))(110(763(638)(711(326(608(680)(30))(681))(205(257(337)(275))(260))))(702(133(103)(628))(610(59(971(323)(883))(368(741)(660)))(20(39)(637(424)(523)))))))(551(729(833(353(689)(263))(482))(544(498)(898(394(429(310)(93))(224(68)(996)))(773(410(321)(206))(382(854)(689))))))(961(477(987)(948(714(157(528)(742))(442(392)(673)))(378)))(319(964(947(923(811)(231))(78))(216(34(561)(536))(691)))(749(989)(793)))))))))(845(423(802(247(372(222(754)(822(238(538(820(148)(569))(83(14)(749)))(820(987(24)(795))(475)))(333(500(697(743)(402))(13))(977(894(744)(831))(728(286)(3))))))(356))(309(252(234)(69(689(813)(340))(701(153)(143(259)(422(48)(799))))))(102(103(496(30(453(291)(959))(377(533)(174)))(422(397(67)(719))(590(332)(260))))(957))(892(400(498(280(476)(834))(162))(125(467(630)(843))(221(604)(446))))(561)))))(922))(764(689(15(120(946)(743(330(596)(527))(779)))(306(947(412(717(787)(490))(906(497(849)(893))(3(433)(378))))(559(717(99(837)(414))(495))(319(623)(760))))(61(680(454(453(479)(206))(567(378)(718)))(669(193(223)(863))(188)))(332(727(577(518)(699))(866(56)(869)))(566)))))(800(860(985(205(148(141(644)(70))(35))(669(808)(191)))(440(648(384(870)(773))(217))(606)))(189(888(618(671(395)(223))(245(624)(662)))(458))(977(172)(500(340(837)(404))(848(189)(800))))))(619)))(625(424(2(876(229)(460))(243(186(741(201(218)(371))(218(473)(249)))(408(581(359)(788))(957)))(435)))(81(993(808)(983))(350)))(889(465(505(461)(670(462)(84(426(806)(377))(53))))(941(956)(551(823)(169(645(359)(643))(661)))))(544(644)(220(699(848(656)(672(163)(964)))(991))(794)))))))(67(500(240(344(375(288(923(979)(467))(191))(49))(328(451)(426)))(162(96(615)(78))(429)))(97))(512(387(310(138(735(1(749(227(983)(201))(828(691)(893)))(1(202(979)(25))(137(56)(497))))(332))(234(383(40(117)(686))(188(763(680)(955))(442)))(553(668(232(699)(219))(136(761)(530)))(81))))(618(959)(440)))(35(734(848)(641(796(503(133(290)(873))(172))(274(570(232)(809))(208(474)(588))))(871)))(486(146(694(82(655(89)(126))(222(268)(721)))(166(286(832)(166))(528(274)(860))))(609(951(420(665)(813))(841(783)(587)))(388)))(861))))(643(925(143(71)(704(542)(137(977(54)(602(103)(293)))(166(997)(327)))))(461(783)(466(545(772(584(890)(726))(462(654)(911)))(876))(251(330(776(291)(578))(545(295)(16)))(176)))))(640)))))) +(573(195(565(887(553)(947(759)(624(744)(995))))(460))(827(479(69)(436(220)(224)))(613(962)(235(134(395(96)(650(2(215)(389))(790(144)(392))))(390))(889(273)(811(124(627(832)(85))(193(540)(579)))(178(176(749)(716))(757(920)(935)))))))))(461(797(233(779(229(535(501(905(894)(663))(493(342)(123)))(266))(443(588(996(376)(964))(712))(11(735)(907(536)(937)))))(369(561(661(123(311)(172))(327))(313(107(545)(357))(701(283)(927))))(700(211)(281(378(496)(83))(719)))))(905(502(215(96)(45(651(418)(169))(846(950)(222))))(653))(499(512(177)(247))(286(309(437)(306(610)(659)))(681(21(603)(88))(336))))))(306(328(984(453)(693(975(540(857)(489))(117(735)(843)))(414(721(827)(250))(134))))(44(577)(168)))(454(999(662)(685))(745(905(977(286(648)(219))(433(105)(526)))(35(564)(112)))(368(809)(450(407)(849(82)(105))))))))(554(880(779(460(181(953(439(964)(897))(59))(929(302)(793(322)(757))))(29(947(324(921)(986))(241(237)(30)))(957(155(629)(455))(183(263)(773)))))(313(884(328)(487(151(246)(136))(316(567)(517))))(707(439)(37))))(522))(777(295(932)(649(223(699(651(542)(980))(46))(363(873(643)(427))(811(219)(314))))(970(188)(802))))(94))))) +(148(110(756(559(287)(578))(66(113(415)(320(364(636(995)(663))(101(538)(479)))(691(916(147)(404))(346))))(610(815(815(775(678)(598))(486(61)(340)))(154(578)(476)))(316(29(286(138)(871))(252(134)(609)))(116(415(708)(0))(511(213)(189)))))))(216(67)(466(999)(637(628)(83(367(636(225)(748))(779(908)(257)))(131))))))(64(826(945(229(308)(123(876(477(308)(319))(226(593)(597)))(290)))(935(931(149)(278(569(219)(357))(390(786)(615))))(151)))(957(25(950(877(90(855)(906))(692))(788(686(969)(182))(293(388)(32))))(662(63(582(900)(917))(256))(552(829(835)(955))(89))))(640(122(501(684)(152(372)(688)))(898))(9(52(528)(731))(946(26)(336(988)(581)))))))(839(307(660)(516(144(711)(605(39(489)(291))(763(359)(54))))(717(942(685)(892(52)(643)))(690(709(776)(996))(990(943)(962))))))(89)))) +(899(768(452(126)(211(769(533(767(835(530)(452(724)(998)))(473(609)(199)))(658(720(295(949(214)(990))(742))(658(361(14)(221))(739(147)(956))))(961(833(353(13)(682))(382))(505(306(5)(294))(293)))))(88(5)(60(164(151(611(920)(883))(302(478)(721)))(50(128(980)(267))(106(797)(814))))(952(524)(959(315)(595(469)(799)))))))(963)))(526(989(940(405(229(306)(310(349(38(828)(601))(887(621)(163)))(269(506(43)(386))(972))))(145(663)(545(406(682(645)(843))(48(286)(85)))(626(569(363)(994))(159(898)(324))))))(718(630(320(874)(703))(214(593(508(448)(695))(808))(945(606(725)(246))(446(949)(81)))))(246(18(695(384(595)(623))(505(772)(457)))(707(82(478)(886))(971)))(985(661)(741)))))(992))(834(313(446)(196))(325(993)(380)))))(853(668(806(258(427(645(35(568(76(935)(273))(690))(687(433(472)(548))(563(155)(118))))(597(70)(868(690)(749))))(562(124(508(43)(205))(14))(888(602(78(93)(914))(742(571)(985)))(476(663)(279(630)(219))))))(434(896(306(585(544)(862(498)(148)))(253))(719))(576(508(670(511)(939(466)(830)))(284))(138(740(646(624)(574))(29(144)(807)))(796(42(784)(264))(500(960)(447)))))))(49(713)(378(732(650)(702(783(320(538)(577))(249))(966(824(870)(272))(740(50)(339)))))(541(449)(521)))))(315))(556(330(759(648(924)(419))(968(332(146(872(999)(201))(351))(908))(253(479(863)(872(926(616)(418))(47(781)(609))))(276(570(772(137)(3))(493(137)(318)))(659(397(45)(440))(941(423)(311)))))))(3(302)(934(6(350(707(265)(372(954)(769)))(406(895)(832(274)(503))))(409(3(124)(399(223)(422)))(107(553(559)(930))(191))))(150(99(744)(784(713(291)(799))(68(905)(760))))(521(491(338(331)(519))(689(160)(261)))(471))))))(978)))) +(149(134(341(476(80(139(817)(642))(458(996(160)(784))(523)))(651(759)(412(819)(770(21)(488)))))(854(707(446(472)(722(765)(275)))(418(80(50)(193))(746(726)(241))))(430(369(450(763)(443))(737(914)(420)))(388))))(238(790)(295(554)(356))))(414(130(492(239(779(975)(105(992)(808)))(292))(89(773(468(99)(723))(688))(334)))(910(938)(650(947(266)(745(92)(143)))(344))))(82(446)(750(545(726)(275))(438(990(374)(571(418)(27)))(380)))))) +(227(232(166(722(506(717(947(527)(500))(563(67)(382)))(63(892)(954)))(665(44(330)(942(691)(618)))(465(593)(104(115)(202)))))(805(14(666)(659(256(927)(575))(536(33)(118))))(405(384(712(514)(50))(678(636)(563)))(133(938(191)(935))(246(572)(501))))))(625(942)(633(201(359(876)(296(672)(961)))(935))(772(478)(339(518)(257(119)(531)))))))(39(482(830)(738))(552(574)(230(52(396(596)(852(144)(702)))(959(35)(448(84)(280))))(478(82(764(856)(325))(235(639)(241)))(935(102)(955(903)(969)))))))) +(80(120(323(691)(921))(672(677(37(216(266(214(530)(786))(522))(440(892(374)(552))(874(459)(699))))(526(113(726)(612(381)(679)))(58(26(401)(490))(956(877)(154)))))(950(197(71)(253(687(573)(853))(873)))(94(936(179(383)(118))(916))(715(161(43)(708))(426(940)(855))))))(671(406(145(970(705(808)(61))(773))(27))(363(857(18(621)(646))(956(402)(553)))(244(997(851)(779))(877))))(229(540(684(512(98)(824))(270(0)(207)))(125))(849(489(255(375)(852))(749(328)(789)))(695))))))(943(462(816)(679(232)(737)))(83(813(553(973)(793(912)(111(744(68)(17))(751(319)(155)))))(421))(205(877(587(145(606(658)(119))(106(939)(254)))(342))(31(912(916(207)(170))(721(501)(219)))(876)))(242))))) +(361(590(696(221)(901(281(6)(151(879(581(678(61(910)(335(883)(850)))(594(951(207)(791))(305(765)(268))))(415))(620(147(147(77(408)(290))(964))(312))(306(160(401)(303(295)(310)))(623(240(822)(16))(954)))))(707(932(749(524)(421(347(502)(426))(391(359)(283))))(251(460)(422)))(152))))(901(26(82(374(22(937(669)(934(988)(456)))(849(320(362)(301))(994(929)(920))))(43(442(219)(621(470)(784)))(382)))(940(771(428)(419(888(604)(459))(545)))(262)))(103(98)(568)))(934(502(826(666)(149(746(544(937)(546))(970))(719)))(164(795(304(963)(331))(675(11(788)(417))(498(575)(876))))(785(290(137(190)(577))(282(759)(196)))(930(697(981)(532))(689(712)(899))))))(304(999(356(178)(95(356(607)(462))(949)))(970(474(38(75)(782))(665(296)(579)))(897(851(296)(235))(244(197)(831)))))(612))))))(522(581)(695(640(493(899)(657))(638(24)(186(128(325(356)(242))(271(415)(765(535(426)(625))(250))))(584(211)(876(82(51)(372(573)(200)))(54(423(34)(578))(669(121)(241))))))))(603(748(52(54)(73(322(931(897(481)(530))(872(314)(551)))(286(825(563)(898))(385(104)(872))))(949(256(34(829)(529))(310))(623))))(309(503(418(136)(331(218(926)(990))(879)))(649))(277(574(277)(762))(225(154(749(899)(415))(187(732)(587)))(713)))))(227)))))(308(903(529(654)(964(711(858)(739(417)(641(120(262(70(430)(586))(405(106)(981)))(185(198)(164(866)(279))))(196(594(708(898)(575))(955(359)(122)))(285(277(356)(940))(638(660)(861)))))))(457(717)(681(437)(199)))))(138))(858(54(193(612(808(544(865(733)(597))(598(215)(666)))(835(934)(450(103(601(482)(443))(881))(186(846)(518)))))(307(466(985(845(772(290)(104))(794))(453(986(870)(695))(367(769)(791))))(236(642(306)(411))(772(696)(198))))(783(156(744(841)(319(929)(303)))(868(711)(693)))(826(518)(49(422(71)(582))(281))))))(972))(146(808(483)(29))(51)))(18)))) +(788(640(948(971)(766))(483(209)(827)))(163(441(655)(638))(812(548(820)(913(798(680)(360(74(823(514)(470))(351(976)(887)))(576)))(537(935)(333(820(900)(256(766)(702)))(650)))))(722(234)(530(865(919(862(46(507)(813))(448))(661(946(721)(811))(927(61)(747))))(253(147(27(892)(843))(63(474)(603)))(198(279(811)(734))(85))))(378(717)(685(726(739(803)(243))(850))(995(140(902)(524))(757))))))))) +(857(510(140(224(959(282)(868(631(4(101)(627))(736(877)(858)))(358(67(502)(189))(352(957)(127)))))(261(463(110(448(380)(708))(877(11)(659)))(138(221(12)(707))(222(313)(983))))(351(42)(3))))(791(533(71)(178(246(996(22)(848))(6(160)(354)))(347(867)(633(333)(67)))))(410(963(372(274(162)(734))(401(130)(638)))(846(28)(872)))(589(341(910(158)(263))(365(715)(77)))(500(859)(746))))))(553(485(71)(463))(99(281)(522(921(683(516(461)(233))(978(908)(702)))(550))(47(364(982(725)(183))(905(14)(340)))(717))))))(520(285(761)(249(827)(526)))(723(918(371(236(158(831(846)(376))(457))(301))(150(542)(428(68(639)(471))(58(948)(370)))))(748))(811(807(284)(433(905)(870)))(517(861)(334(621)(241))))))) +(238(539(118(169(357(407(684)(763(960)(830(201)(670))))(150(34)(592(628(34)(637))(856(801)(263)))))(769(412(827(41(203)(401))(633(308)(456)))(36))(964)))(668(158)(365(60)(57))))(814(492(496)(991(669)(2(7(92(369)(446))(30(749)(636)))(732(745)(825(188)(927))))))(468(453(535(594)(918(622(444)(977))(970(912)(542))))(802))(301(993)(106(416(81(627)(262))(325(512)(341)))(570(402)(611(61)(443))))))))(837(258(572(790)(868))(369(153)(353(496(100(656)(928(951)(670)))(895))(284(447(981)(178))(815(738(46)(329))(316(533)(400)))))))(444(214)(608(972(493)(888(261(945(106)(362))(7))(541(822)(169(743)(852)))))(585(326)(986(411(863(623)(543))(406))(786(1(63)(161))(380(555)(700))))))))) +(671(793(527(312(836)(718(695(194)(835(728)(229(397(357)(551))(492(215)(707)))))(540(9(30)(333(543(393)(966))(842(319)(355))))(328(218)(830)))))(721(779)(410(234)(792(885)(268)))))(104(853)(120(439)(544))))(56(119(489(636(610(319)(963(970(490)(905))(657)))(498))(738))(138(147(514(288(913(358(868)(993))(106(753)(200)))(502(34(253)(667))(901(472)(257))))(373(191(927(249)(960))(769(976)(650)))(995(929(142)(156))(6))))(968(322(115(616)(670(469)(795)))(692))(327(892(967(882)(952))(102(796)(489)))(21(2(720)(425))(907(436)(994))))))(998(405(183(477(640(381)(485))(238(263)(417)))(490(207(900)(880))(959)))(350(707)(839(834)(350(164)(213)))))(899(401(520(759(658)(295))(952(568)(862)))(487(17(474)(87))(40)))(692)))))(594(632(489)(296))(597(233(589(461)(473(735(490)(17(566)(720)))(527(767(322)(719))(308(895)(138)))))(730))(37))))) +(33(822(142(902(619)(919(27(798(998(535)(995))(711(121)(302)))(173))(752(490)(820(139(529)(643))(780(402)(231))))))(122))(17(627(830(744)(581(387(417(758)(582))(579(522)(5)))(818(815)(351(510)(757)))))(687))(824)))(186(104(350(263(319(601(366(6)(213))(651))(328(211)(28)))(198(603)(846)))(629))(808(164)(750(461(945(968(230)(519))(1))(951))(492(939(811(611)(392))(559(952)(719)))(743(675(51)(595))(411(282)(300)))))))(724(840(440)(840(638(689(20(523)(193))(258(999)(221)))(629))(675(513)(856(904(650)(986))(564)))))(588(95)(396(476)(37(424(804(772)(698))(86(719)(158)))(96))))))) \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Tiefen_Breitensuche/readme.adoc b/Quellcodes/Alg_DS_Tiefen_Breitensuche/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Tiefen_Breitensuche/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/.gitignore b/Quellcodes/Alg_DS_Verkettete_Liste/.gitignore new file mode 100644 index 0000000..2cc0cb6 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/.gitignore @@ -0,0 +1,7 @@ +**/*.sh +**/*.class +**/*.ctxt +repo.adoc +repo_subtree.adoc +/alt +/hide diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/README.TXT b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/README.TXT new file mode 100644 index 0000000..6be5ca6 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Verkettete Liste +PROJEKTZWECK: Implementation einer einfach verketteten Liste +VERSION oder DATUM: 3.10.2020 +WIE IST DAS PROJEKT ZU STARTEN: Testfälle in TesterIterativ bzw. TesterRekursiv ausführen +AUTOR(EN): Rainer Helfrich, ZPG Informatik \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/TesterIterativ.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/TesterIterativ.java new file mode 100644 index 0000000..3c7aaee --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/TesterIterativ.java @@ -0,0 +1,24 @@ +import liste.*; +import tests.*; + +import org.junit.Before; + +/** + * Die Test-Klasse TesterIterativ. + * + * @author Rainer Helfrich + * @version 3.10.2020 + */ +public class TesterIterativ extends Tester +{ + /** + * Setzt das Testgerüst fuer den Test. + * + * Wird vor jeder Testfall-Methode aufgerufen. + */ + @Before + public void setUp() + { + dieListe = new ListeIterativ(); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/TesterRekursiv.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/TesterRekursiv.java new file mode 100644 index 0000000..c22462b --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/TesterRekursiv.java @@ -0,0 +1,24 @@ +import liste.*; +import tests.*; + +import org.junit.Before; + +/** + * Die Test-Klasse TesterIterativ. + * + * @author Rainer Helfrich + * @version 3.10.2020 + */ +public class TesterRekursiv extends Tester +{ + /** + * Setzt das Testgerüst fuer den Test. + * + * Wird vor jeder Testfall-Methode aufgerufen. + */ + @Before + public void setUp() + { + dieListe = new ListeRekursiv(); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/Liste.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/Liste.java new file mode 100644 index 0000000..7d5c209 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/Liste.java @@ -0,0 +1,59 @@ +package liste; + +/** + * Abstrakte Klasse Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Liste +{ + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public abstract int laenge(); + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public abstract T getNtenWert(int n); + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public abstract void anhaengen(T val); + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public abstract void einfuegenBei(int index, T val); + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public abstract void ausgeben(); + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public abstract boolean enthaelt(T val); + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public abstract void entferneBei(int index); + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public abstract boolean istLeer(); +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/ListeIterativ.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/ListeIterativ.java new file mode 100644 index 0000000..0353fbe --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/ListeIterativ.java @@ -0,0 +1,98 @@ +package liste; + +/** + * Klasse ListeIterativ + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeIterativ extends Liste +{ + //# TODO: Legen Sie einen Verweis auf das erste Element an + + /** + * Erzeugt eine neue Liste + */ + public ListeIterativ() + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public int laenge() + { + //# TODO: Hier ist etwas zu tun + return -1; + } + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public T getNtenWert(int n) + { + //# TODO: Hier ist etwas zu tun + return null; + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public void ausgeben() + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public boolean enthaelt(T val) + { + //# TODO: Hier ist etwas zu tun + return false; + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public boolean istLeer() + { + //# TODO: Hier ist etwas zu tun + return true; + } + +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/ListeRekursiv.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/ListeRekursiv.java new file mode 100644 index 0000000..2ccef21 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/ListeRekursiv.java @@ -0,0 +1,97 @@ +package liste; + +/** + * Klasse ListeRekursiv + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeRekursiv extends Liste +{ + //# TODO: Legen Sie einen Verweis auf das erste Element an + + /** + * Erzeugt eine neue Liste + */ + public ListeRekursiv() + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public int laenge() + { + //# TODO: Hier ist etwas zu tun + return -1; + } + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public T getNtenWert(int n) + { + //# TODO: Hier ist etwas zu tun + return null; + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public void ausgeben() + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public boolean enthaelt(T val) + { + //# TODO: Hier ist etwas zu tun + return false; + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + //# TODO: Hier ist etwas zu tun + } + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public boolean istLeer() + { + //# TODO: Hier ist etwas zu tun + return true; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/Listenknoten.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/Listenknoten.java new file mode 100644 index 0000000..e185d3d --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/Listenknoten.java @@ -0,0 +1,32 @@ +package liste; + +/** + * Klasse Listenknoten + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Listenknoten +{ + /** + * Der Datenwert des Listenknotens + */ + public T daten; + + /** + * Der Nachfolger des Listenknotens + */ + public Listenknoten nachfolger; + + /** + * Erzeugt einen neuen Listenknoten + * + * @param daten Der Datenwert des Knotens + * @param nachfolger Der Nachfolger des Knotens + */ + public Listenknoten(T daten, Listenknoten nachfolger) + { + this.daten = daten; + this.nachfolger = nachfolger; + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/package.bluej b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/package.bluej new file mode 100644 index 0000000..b17e129 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/liste/package.bluej @@ -0,0 +1,48 @@ +#BlueJ package file +objectbench.height=81 +objectbench.width=760 +package.divider.horizontal=0.6 +package.divider.vertical=0.824 +package.editor.height=405 +package.editor.width=649 +package.editor.x=20 +package.editor.y=20 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=0 +package.numTargets=4 +package.showExtends=true +package.showUses=true +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=ListeIterativ +target1.showInterface=false +target1.type=ClassTarget +target1.width=120 +target1.x=280 +target1.y=240 +target2.height=50 +target2.name=Liste +target2.showInterface=false +target2.type=AbstractTarget +target2.width=80 +target2.x=210 +target2.y=150 +target3.height=50 +target3.name=ListeRekursiv +target3.showInterface=false +target3.type=ClassTarget +target3.width=130 +target3.x=110 +target3.y=240 +target4.height=50 +target4.name=Listenknoten +target4.showInterface=false +target4.type=ClassTarget +target4.width=170 +target4.x=300 +target4.y=70 diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/package.bluej b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/package.bluej new file mode 100644 index 0000000..eb893fb --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/package.bluej @@ -0,0 +1,51 @@ +#BlueJ package file +editor.fx.0.height=739 +editor.fx.0.width=1149 +editor.fx.0.x=713 +editor.fx.0.y=85 +objectbench.height=66 +objectbench.width=1896 +package.divider.horizontal=0.6 +package.divider.vertical=0.9236401673640168 +package.editor.height=876 +package.editor.width=1785 +package.editor.x=0 +package.editor.y=0 +package.frame.height=1056 +package.frame.width=1936 +package.numDependencies=0 +package.numTargets=4 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=TesterRekursiv +target1.showInterface=false +target1.type=UnitTestTargetJunit4 +target1.width=120 +target1.x=340 +target1.y=350 +target2.height=62 +target2.name=tests +target2.type=PackageTarget +target2.width=80 +target2.x=70 +target2.y=10 +target3.height=62 +target3.name=liste +target3.type=PackageTarget +target3.width=80 +target3.x=340 +target3.y=180 +target4.height=50 +target4.name=TesterIterativ +target4.showInterface=false +target4.type=UnitTestTargetJunit4 +target4.width=110 +target4.x=210 +target4.y=350 diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest1.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest1.java new file mode 100644 index 0000000..95ab1bf --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest1.java @@ -0,0 +1,2108 @@ +package tests; +import static org.junit.Assert.*; +import liste.*; +/** + * Die Test-Klasse SubTest1. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest1 +{ + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{719}); + + assertFalse("Fehler: Element 84 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(84)); + dieListe.anhaengen(320); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320}); + + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertFalse("Fehler: Element 375 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(375)); + assertFalse("Fehler: Element 691 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(691)); + dieListe.anhaengen(112); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646}); + + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608}); + + assertFalse("Fehler: Element 408 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(408)); + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718}); + + dieListe.anhaengen(726); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726}); + + assertFalse("Fehler: Element 267 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(267)); + assertTrue("Fehler: Element 112 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(241); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241}); + + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297}); + + assertFalse("Fehler: Element 21 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(21)); + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290}); + + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534}); + + assertFalse("Fehler: Element 4 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(4)); + assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718)); + assertFalse("Fehler: Element 710 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(710)); + dieListe.anhaengen(671); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671}); + + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871}); + + dieListe.anhaengen(986); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986}); + + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958}); + + assertTrue("Fehler: Element 534 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(534)); + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + dieListe.anhaengen(98); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98}); + + assertTrue("Fehler: Element 98 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(98)); + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertTrue("Fehler: Element 671 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(671)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertTrue("Fehler: Element 112 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(112)); + assertTrue("Fehler: Element 608 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(608)); + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + assertTrue("Fehler: Element 608 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(608)); + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102}); + + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19}); + + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126}); + + dieListe.anhaengen(771); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771}); + + assertFalse("Fehler: Element 5 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(5)); + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780}); + + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226}); + + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + assertFalse("Fehler: Element 8 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(8)); + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936}); + + assertFalse("Fehler: Element 357 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(357)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + dieListe.anhaengen(986); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986}); + + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335}); + + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254}); + + assertFalse("Fehler: Element 580 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(580)); + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526}); + + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528}); + + assertFalse("Fehler: Element 62 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(62)); + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340}); + + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + assertFalse("Fehler: Element 70 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(70)); + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967}); + + assertTrue("Fehler: Element 731 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(731)); + assertFalse("Fehler: Element 229 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(229)); + assertTrue("Fehler: Element 936 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(936)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + assertFalse("Fehler: Element 764 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(764)); + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83}); + + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + assertFalse("Fehler: Element 544 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(544)); + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308}); + + assertTrue("Fehler: Element 528 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(528)); + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254}); + + assertFalse("Fehler: Element 464 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(464)); + assertFalse("Fehler: Element 468 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(468)); + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.anhaengen(794); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217}); + + assertFalse("Fehler: Element 333 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(333)); + dieListe.anhaengen(210); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210}); + + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65}); + + dieListe.anhaengen(415); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793}); + + assertFalse("Fehler: Element 883 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(883)); + assertFalse("Fehler: Element 463 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(463)); + dieListe.anhaengen(551); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793,551}); + + assertTrue("Fehler: Element 958 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(958)); + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793,551,368}); + + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793,551,368,466}); + + assertTrue("Fehler: Element 780 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(780)); + assertFalse("Fehler: Element 850 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(850)); + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(642); + Tester.pruefeListenInhalt(dieListe, new int[]{642}); + + assertFalse("Fehler: Element 158 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(158)); + dieListe.anhaengen(879); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879}); + + dieListe.anhaengen(770); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770}); + + dieListe.anhaengen(181); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181}); + + assertFalse("Fehler: Element 566 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(566)); + assertTrue("Fehler: Element 181 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(181)); + assertFalse("Fehler: Element 70 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(70)); + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25}); + + dieListe.anhaengen(811); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811}); + + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366}); + + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709}); + + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290}); + + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748}); + + dieListe.anhaengen(203); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203}); + + assertFalse("Fehler: Element 683 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(683)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47}); + + dieListe.anhaengen(11); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11}); + + dieListe.anhaengen(483); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483}); + + dieListe.anhaengen(345); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896}); + + dieListe.anhaengen(602); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602}); + + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467}); + + assertFalse("Fehler: Element 609 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(609)); + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254}); + + assertFalse("Fehler: Element 696 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(696)); + assertTrue("Fehler: Element 602 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(602)); + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26}); + + assertTrue("Fehler: Element 483 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(483)); + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123}); + + dieListe.anhaengen(0); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0}); + + dieListe.anhaengen(586); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586}); + + assertFalse("Fehler: Element 487 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(487)); + assertFalse("Fehler: Element 643 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(643)); + dieListe.anhaengen(558); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558}); + + dieListe.anhaengen(132); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132}); + + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322}); + + assertFalse("Fehler: Element 671 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(671)); + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473}); + + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275}); + + assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709)); + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65}); + + assertFalse("Fehler: Element 427 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(427)); + assertTrue("Fehler: Element 25 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(25)); + assertTrue("Fehler: Element 366 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(366)); + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124}); + + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704}); + + dieListe.anhaengen(509); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509}); + + dieListe.anhaengen(489); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329}); + + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626}); + + assertTrue("Fehler: Element 586 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(586)); + dieListe.anhaengen(691); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691}); + + assertTrue("Fehler: Element 285 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(285)); + dieListe.anhaengen(747); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861}); + + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353}); + + assertTrue("Fehler: Element 65 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(65)); + dieListe.anhaengen(32); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32}); + + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402}); + + dieListe.anhaengen(912); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912}); + + dieListe.anhaengen(590); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644}); + + dieListe.anhaengen(13); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263}); + + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480}); + + assertFalse("Fehler: Element 844 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(844)); + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969}); + + dieListe.anhaengen(31); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31}); + + dieListe.anhaengen(183); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183}); + + assertFalse("Fehler: Element 936 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(936)); + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359}); + + dieListe.anhaengen(42); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359,42}); + + assertFalse("Fehler: Element 100 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 770 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(770)); + dieListe.anhaengen(601); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359,42,601}); + + assertTrue("Fehler: Element 183 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(183)); + assertTrue("Fehler: Element 31 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(31)); + assertFalse("Fehler: Element 177 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(177)); + assertTrue("Fehler: Element 181 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(181)); + assertTrue("Fehler: Element 263 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(263)); + assertTrue("Fehler: Element 345 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(345)); + assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709)); + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(239); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359,42,601,239}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{877}); + + dieListe.anhaengen(934); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897}); + + dieListe.anhaengen(687); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687}); + + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96}); + + assertFalse("Fehler: Element 716 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(716)); + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936}); + + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531}); + + dieListe.anhaengen(405); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405}); + + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357}); + + assertTrue("Fehler: Element 936 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(936)); + assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198)); + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481}); + + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191}); + + assertFalse("Fehler: Element 160 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(160)); + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543}); + + dieListe.anhaengen(706); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706}); + + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3}); + + dieListe.anhaengen(111); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111}); + + assertFalse("Fehler: Element 450 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(450)); + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + assertFalse("Fehler: Element 319 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(319)); + dieListe.anhaengen(844); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844}); + + assertFalse("Fehler: Element 62 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(62)); + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + dieListe.anhaengen(882); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882}); + + dieListe.anhaengen(847); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847}); + + dieListe.anhaengen(542); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515}); + + assertTrue("Fehler: Element 191 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(191)); + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + dieListe.anhaengen(336); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336}); + + assertFalse("Fehler: Element 857 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(857)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932}); + + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + dieListe.anhaengen(886); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886}); + + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660}); + + assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672)); + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15}); + + assertTrue("Fehler: Element 543 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(543)); + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672}); + + dieListe.anhaengen(525); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525}); + + dieListe.anhaengen(933); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933}); + + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620}); + + assertTrue("Fehler: Element 531 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(531)); + assertFalse("Fehler: Element 816 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(816)); + assertTrue("Fehler: Element 882 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(882)); + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392}); + + assertTrue("Fehler: Element 886 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(886)); + dieListe.anhaengen(41); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41}); + + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314}); + + assertTrue("Fehler: Element 687 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(687)); + assertFalse("Fehler: Element 347 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(347)); + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900}); + + dieListe.anhaengen(794); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896}); + + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480}); + + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490}); + + assertFalse("Fehler: Element 831 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(831)); + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157}); + + assertTrue("Fehler: Element 314 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(314)); + assertTrue("Fehler: Element 886 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(886)); + assertTrue("Fehler: Element 882 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(882)); + assertFalse("Fehler: Element 858 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(858)); + dieListe.anhaengen(48); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359}); + + assertFalse("Fehler: Element 54 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(54)); + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496}); + + assertFalse("Fehler: Element 298 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(298)); + dieListe.anhaengen(231); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231}); + + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + assertFalse("Fehler: Element 369 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(369)); + assertFalse("Fehler: Element 621 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(621)); + assertTrue("Fehler: Element 41 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(41)); + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116}); + + assertFalse("Fehler: Element 67 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(67)); + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108}); + + dieListe.anhaengen(811); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811}); + + assertTrue("Fehler: Element 620 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(620)); + assertFalse("Fehler: Element 344 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(344)); + assertFalse("Fehler: Element 151 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(151)); + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + assertTrue("Fehler: Element 706 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(706)); + dieListe.anhaengen(662); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662}); + + dieListe.anhaengen(929); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929}); + + assertFalse("Fehler: Element 234 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(234)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686}); + + dieListe.anhaengen(657); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657}); + + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905}); + + dieListe.anhaengen(172); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172}); + + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172,25}); + + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172,25,45}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172,25,45,372}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{312}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertFalse("Fehler: Element 63 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(63)); + assertFalse("Fehler: Element 682 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(682)); + assertFalse("Fehler: Element 97 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(97)); + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361}); + + assertTrue("Fehler: Element 361 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(361)); + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387}); + + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727}); + + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633}); + + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527}); + + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361}); + + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890}); + + assertFalse("Fehler: Element 946 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(946)); + dieListe.anhaengen(742); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742}); + + assertFalse("Fehler: Element 228 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(228)); + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816}); + + dieListe.anhaengen(142); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349}); + + assertFalse("Fehler: Element 909 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(909)); + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + assertTrue("Fehler: Element 742 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(742)); + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366}); + + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675}); + + dieListe.anhaengen(114); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114}); + + assertFalse("Fehler: Element 154 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(154)); + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686}); + + assertFalse("Fehler: Element 724 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(724)); + assertFalse("Fehler: Element 778 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(778)); + assertFalse("Fehler: Element 152 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(152)); + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474}); + + dieListe.anhaengen(220); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220}); + + dieListe.anhaengen(28); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28}); + + dieListe.anhaengen(738); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738}); + + dieListe.anhaengen(987); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987}); + + assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644)); + assertFalse("Fehler: Element 496 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(496)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650}); + + assertTrue("Fehler: Element 650 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(650)); + assertTrue("Fehler: Element 349 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(349)); + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436}); + + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71}); + + assertFalse("Fehler: Element 333 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(333)); + assertFalse("Fehler: Element 563 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(563)); + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259}); + + dieListe.anhaengen(850); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850}); + + assertFalse("Fehler: Element 984 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(984)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + assertFalse("Fehler: Element 634 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(993); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993}); + + assertFalse("Fehler: Element 377 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(377)); + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712}); + + assertFalse("Fehler: Element 130 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(130)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226}); + + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + assertTrue("Fehler: Element 650 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(650)); + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890}); + + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401}); + + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355}); + + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191}); + + assertFalse("Fehler: Element 186 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(186)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2}); + + dieListe.anhaengen(88); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88}); + + assertTrue("Fehler: Element 738 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(738)); + assertFalse("Fehler: Element 614 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(614)); + assertTrue("Fehler: Element 361 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(361)); + assertFalse("Fehler: Element 58 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(58)); + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699}); + + assertFalse("Fehler: Element 813 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(813)); + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117}); + + assertTrue("Fehler: Element 71 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(71)); + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + assertFalse("Fehler: Element 40 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(40)); + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869}); + + dieListe.anhaengen(590); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590}); + + dieListe.anhaengen(161); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161}); + + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161,740}); + + assertFalse("Fehler: Element 610 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(610)); + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161,740,344}); + + dieListe.anhaengen(381); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161,740,344,381}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(317); + Tester.pruefeListenInhalt(dieListe, new int[]{317}); + + assertTrue("Fehler: Element 317 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(317)); + dieListe.anhaengen(256); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256}); + + assertFalse("Fehler: Element 698 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(698)); + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255}); + + assertFalse("Fehler: Element 131 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(131)); + assertFalse("Fehler: Element 109 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(109)); + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3}); + + dieListe.anhaengen(229); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229}); + + dieListe.anhaengen(764); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764}); + + dieListe.anhaengen(67); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67}); + + dieListe.anhaengen(231); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231}); + + assertTrue("Fehler: Element 764 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(764)); + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312}); + + dieListe.anhaengen(517); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517}); + + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969}); + + assertFalse("Fehler: Element 164 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(164)); + dieListe.anhaengen(621); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621}); + + assertFalse("Fehler: Element 267 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(267)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + assertFalse("Fehler: Element 369 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(369)); + assertFalse("Fehler: Element 749 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(749)); + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + assertTrue("Fehler: Element 517 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(517)); + dieListe.anhaengen(656); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656}); + + dieListe.anhaengen(279); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279}); + + assertFalse("Fehler: Element 400 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(400)); + assertTrue("Fehler: Element 305 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(305)); + assertTrue("Fehler: Element 256 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(256)); + assertFalse("Fehler: Element 958 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(958)); + assertFalse("Fehler: Element 88 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(88)); + assertFalse("Fehler: Element 922 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(922)); + dieListe.anhaengen(760); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286}); + + assertFalse("Fehler: Element 185 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(185)); + dieListe.anhaengen(901); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901}); + + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780}); + + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertTrue("Fehler: Element 286 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(286)); + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949}); + + dieListe.anhaengen(629); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629}); + + dieListe.anhaengen(0); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0}); + + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156)); + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178}); + + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487}); + + assertTrue("Fehler: Element 656 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(656)); + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + assertTrue("Fehler: Element 0 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(0)); + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + assertFalse("Fehler: Element 432 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(432)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736}); + + dieListe.anhaengen(59); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59}); + + dieListe.anhaengen(427); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427}); + + dieListe.anhaengen(327); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327}); + + assertTrue("Fehler: Element 279 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(279)); + assertFalse("Fehler: Element 676 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(676)); + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388}); + + dieListe.anhaengen(9); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225)); + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521}); + + dieListe.anhaengen(206); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206}); + + assertFalse("Fehler: Element 565 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(565)); + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411}); + + assertTrue("Fehler: Element 621 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(621)); + dieListe.anhaengen(156); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156}); + + assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231)); + dieListe.anhaengen(610); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610}); + + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + assertFalse("Fehler: Element 881 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(881)); + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767}); + + assertTrue("Fehler: Element 764 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(764)); + dieListe.anhaengen(592); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592}); + + assertFalse("Fehler: Element 197 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(197)); + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95}); + + assertTrue("Fehler: Element 3 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(3)); + dieListe.anhaengen(636); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264}); + + assertTrue("Fehler: Element 156 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(156)); + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852}); + + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653}); + + dieListe.anhaengen(224); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224}); + + assertTrue("Fehler: Element 0 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(0)); + assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231)); + dieListe.anhaengen(398); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224,398}); + + assertFalse("Fehler: Element 729 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(729)); + dieListe.anhaengen(754); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224,398,754}); + + assertTrue("Fehler: Element 95 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(95)); + assertTrue("Fehler: Element 901 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(901)); + dieListe.anhaengen(237); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224,398,754,237}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(800); + Tester.pruefeListenInhalt(dieListe, new int[]{800}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254}); + + assertFalse("Fehler: Element 255 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(255)); + assertTrue("Fehler: Element 254 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(254)); + dieListe.anhaengen(638); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638}); + + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189}); + + assertFalse("Fehler: Element 426 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(426)); + dieListe.anhaengen(571); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571}); + + assertFalse("Fehler: Element 339 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(339)); + assertTrue("Fehler: Element 437 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413}); + + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116}); + + dieListe.anhaengen(741); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741}); + + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870}); + + dieListe.anhaengen(323); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.anhaengen(859); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859}); + + dieListe.anhaengen(847); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847}); + + assertFalse("Fehler: Element 941 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(941)); + dieListe.anhaengen(759); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759}); + + assertFalse("Fehler: Element 914 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(914)); + assertTrue("Fehler: Element 437 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(218); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189}); + + assertTrue("Fehler: Element 218 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(218)); + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862}); + + dieListe.anhaengen(540); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540}); + + dieListe.anhaengen(580); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + assertTrue("Fehler: Element 465 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(465)); + assertFalse("Fehler: Element 813 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(813)); + assertFalse("Fehler: Element 103 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(103)); + dieListe.anhaengen(370); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370}); + + assertTrue("Fehler: Element 254 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(254)); + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293}); + + assertFalse("Fehler: Element 618 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(618)); + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(291); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291}); + + assertTrue("Fehler: Element 218 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(218)); + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786}); + + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536}); + + dieListe.anhaengen(824); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824}); + + assertFalse("Fehler: Element 215 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(215)); + assertFalse("Fehler: Element 283 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(283)); + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622}); + + assertFalse("Fehler: Element 22 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(22)); + assertFalse("Fehler: Element 954 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(954)); + dieListe.anhaengen(91); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91}); + + dieListe.anhaengen(422); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422}); + + dieListe.anhaengen(301); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301}); + + assertFalse("Fehler: Element 614 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(614)); + assertTrue("Fehler: Element 824 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(824)); + dieListe.anhaengen(636); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636}); + + assertTrue("Fehler: Element 847 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(847)); + assertTrue("Fehler: Element 26 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(26)); + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.anhaengen(661); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637}); + + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700}); + + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651}); + + assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239)); + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299}); + + dieListe.anhaengen(714); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714}); + + dieListe.anhaengen(8); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8}); + + assertTrue("Fehler: Element 580 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(580)); + assertTrue("Fehler: Element 323 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(323)); + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154}); + + assertTrue("Fehler: Element 862 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(862)); + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749}); + + assertTrue("Fehler: Element 465 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(465)); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923}); + + assertTrue("Fehler: Element 700 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(700)); + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603}); + + dieListe.anhaengen(252); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252}); + + assertFalse("Fehler: Element 488 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(488)); + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869}); + + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); + assertTrue("Fehler: Element 749 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(749)); + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.anhaengen(158); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + assertFalse("Fehler: Element 416 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(416)); + dieListe.anhaengen(459); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158,459}); + + assertFalse("Fehler: Element 856 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(856)); + dieListe.anhaengen(58); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158,459,58}); + + dieListe.anhaengen(230); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158,459,58,230}); + + assertFalse("Fehler: Element 168 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(168)); + assertTrue("Fehler: Element 540 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(540)); + assertTrue("Fehler: Element 536 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(536)); + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(16); + Tester.pruefeListenInhalt(dieListe, new int[]{16}); + + assertFalse("Fehler: Element 785 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(785)); + dieListe.anhaengen(607); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607}); + + assertFalse("Fehler: Element 61 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(61)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(399); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399}); + + assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + assertTrue("Fehler: Element 607 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(607)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219}); + + assertTrue("Fehler: Element 219 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(219)); + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96}); + + assertFalse("Fehler: Element 746 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(746)); + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608}); + + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + dieListe.anhaengen(831); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831}); + + dieListe.anhaengen(53); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53}); + + dieListe.anhaengen(379); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379}); + + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280}); + + dieListe.anhaengen(802); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527}); + + assertFalse("Fehler: Element 917 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(917)); + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333}); + + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606}); + + dieListe.anhaengen(713); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713}); + + assertFalse("Fehler: Element 434 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(434)); + assertFalse("Fehler: Element 794 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(794)); + dieListe.anhaengen(724); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724}); + + dieListe.anhaengen(244); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244}); + + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6}); + + assertTrue("Fehler: Element 6 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(6)); + assertTrue("Fehler: Element 606 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(606)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertTrue("Fehler: Element 608 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(608)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(472); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472}); + + dieListe.anhaengen(188); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637}); + + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 606 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(606)); + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + dieListe.anhaengen(833); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833}); + + dieListe.anhaengen(886); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886}); + + dieListe.anhaengen(895); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576}); + + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + dieListe.anhaengen(224); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224}); + + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2}); + + assertFalse("Fehler: Element 868 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(868)); + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + assertFalse("Fehler: Element 932 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(932)); + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909}); + + assertFalse("Fehler: Element 519 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(519)); + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + dieListe.anhaengen(456); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456}); + + dieListe.anhaengen(588); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588}); + + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + dieListe.anhaengen(692); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692}); + + assertFalse("Fehler: Element 43 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(43)); + assertFalse("Fehler: Element 880 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(880)); + dieListe.anhaengen(342); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342}); + + assertFalse("Fehler: Element 795 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(795)); + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95}); + + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + assertFalse("Fehler: Element 387 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(387)); + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.anhaengen(386); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386}); + + assertFalse("Fehler: Element 846 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(846)); + dieListe.anhaengen(398); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398}); + + assertFalse("Fehler: Element 665 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(665)); + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251}); + + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535}); + + dieListe.anhaengen(856); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856}); + + dieListe.anhaengen(602); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602}); + + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921}); + + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645}); + + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertFalse("Fehler: Element 783 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(783)); + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82}); + + dieListe.anhaengen(971); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971,245}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertFalse("Fehler: Element 43 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(43)); + assertFalse("Fehler: Element 653 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(653)); + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971,245,955}); + + dieListe.anhaengen(978); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971,245,955,978}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{557}); + + assertFalse("Fehler: Element 184 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(184)); + dieListe.anhaengen(265); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265}); + + assertFalse("Fehler: Element 357 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(357)); + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366}); + + assertFalse("Fehler: Element 596 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(596)); + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743}); + + dieListe.anhaengen(893); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893}); + + dieListe.anhaengen(423); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423}); + + dieListe.anhaengen(29); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29}); + + assertTrue("Fehler: Element 423 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(423)); + assertFalse("Fehler: Element 98 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(98)); + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957}); + + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + dieListe.anhaengen(408); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + dieListe.anhaengen(41); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41}); + + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653}); + + assertFalse("Fehler: Element 648 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(648)); + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402}); + + assertTrue("Fehler: Element 265 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(265)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932}); + + assertTrue("Fehler: Element 82 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(82)); + assertFalse("Fehler: Element 282 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(282)); + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727}); + + assertFalse("Fehler: Element 405 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(405)); + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(393); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393}); + + assertFalse("Fehler: Element 21 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(21)); + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19}); + + assertTrue("Fehler: Element 957 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(957)); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547}); + + assertFalse("Fehler: Element 33 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(33)); + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152}); + + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6}); + + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531}); + + assertFalse("Fehler: Element 543 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(543)); + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + assertTrue("Fehler: Element 932 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(932)); + dieListe.anhaengen(444); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444}); + + dieListe.anhaengen(70); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70}); + + assertFalse("Fehler: Element 315 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(315)); + assertFalse("Fehler: Element 363 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(363)); + dieListe.anhaengen(464); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464}); + + dieListe.anhaengen(855); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855}); + + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40}); + + dieListe.anhaengen(716); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716}); + + dieListe.anhaengen(584); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584}); + + assertFalse("Fehler: Element 262 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(262)); + assertTrue("Fehler: Element 704 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(704)); + assertTrue("Fehler: Element 70 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(70)); + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845}); + + assertTrue("Fehler: Element 494 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(494)); + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196}); + + dieListe.anhaengen(261); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261}); + + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178}); + + dieListe.anhaengen(232); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232}); + + dieListe.anhaengen(163); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163}); + + dieListe.anhaengen(946); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946}); + + assertTrue("Fehler: Element 946 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(946)); + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(177); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177}); + + assertFalse("Fehler: Element 633 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(633)); + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434}); + + assertTrue("Fehler: Element 177 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(177)); + dieListe.anhaengen(614); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186}); + + assertFalse("Fehler: Element 339 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(339)); + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178}); + + assertTrue("Fehler: Element 82 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(82)); + dieListe.anhaengen(242); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242}); + + dieListe.anhaengen(808); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808}); + + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473}); + + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623}); + + dieListe.anhaengen(673); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673}); + + assertTrue("Fehler: Element 531 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(531)); + assertFalse("Fehler: Element 447 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(447)); + assertFalse("Fehler: Element 147 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(147)); + dieListe.anhaengen(179); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179}); + + dieListe.anhaengen(52); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52}); + + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.anhaengen(944); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944}); + + dieListe.anhaengen(88); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944,88}); + + dieListe.anhaengen(903); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944,88,903}); + + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944,88,903,866}); + + assertFalse("Fehler: Element 728 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(728)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{975}); + + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395}); + + dieListe.anhaengen(147); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147}); + + dieListe.anhaengen(806); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806}); + + dieListe.anhaengen(192); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192}); + + dieListe.anhaengen(107); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107}); + + assertFalse("Fehler: Element 168 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(168)); + dieListe.anhaengen(209); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209}); + + assertFalse("Fehler: Element 915 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(915)); + assertFalse("Fehler: Element 250 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(250)); + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + assertTrue("Fehler: Element 147 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(147)); + dieListe.anhaengen(821); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821}); + + assertFalse("Fehler: Element 990 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(990)); + assertTrue("Fehler: Element 806 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(806)); + dieListe.anhaengen(572); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572}); + + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711}); + + dieListe.anhaengen(779); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779}); + + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333}); + + dieListe.anhaengen(663); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340}); + + dieListe.anhaengen(294); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294}); + + assertFalse("Fehler: Element 109 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(109)); + assertFalse("Fehler: Element 444 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(444)); + assertFalse("Fehler: Element 280 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(280)); + assertFalse("Fehler: Element 11 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(11)); + assertFalse("Fehler: Element 614 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(614)); + assertFalse("Fehler: Element 470 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(470)); + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931}); + + dieListe.anhaengen(76); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76}); + + assertFalse("Fehler: Element 64 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606}); + + assertFalse("Fehler: Element 371 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(371)); + dieListe.anhaengen(331); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331}); + + assertTrue("Fehler: Element 331 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(331)); + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271}); + + assertFalse("Fehler: Element 7 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(7)); + assertTrue("Fehler: Element 821 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(821)); + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793}); + + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + assertFalse("Fehler: Element 547 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(547)); + assertFalse("Fehler: Element 114 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(114)); + assertTrue("Fehler: Element 663 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(663)); + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570}); + + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15}); + + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871}); + + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631}); + + assertFalse("Fehler: Element 490 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(490)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328}); + + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362}); + + dieListe.anhaengen(46); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46}); + + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276}); + + assertFalse("Fehler: Element 738 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(738)); + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertFalse("Fehler: Element 245 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(245)); + assertFalse("Fehler: Element 314 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(314)); + assertTrue("Fehler: Element 631 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(631)); + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318}); + + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920}); + + assertFalse("Fehler: Element 861 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(861)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932}); + + assertTrue("Fehler: Element 333 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(333)); + assertTrue("Fehler: Element 46 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(46)); + assertTrue("Fehler: Element 362 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(362)); + assertTrue("Fehler: Element 46 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(46)); + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723}); + + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + assertFalse("Fehler: Element 199 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(199)); + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890}); + + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909}); + + dieListe.anhaengen(399); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399}); + + dieListe.anhaengen(143); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143}); + + assertFalse("Fehler: Element 605 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(605)); + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297}); + + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788}); + + dieListe.anhaengen(407); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407}); + + assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15)); + assertFalse("Fehler: Element 747 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(747)); + assertFalse("Fehler: Element 235 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(235)); + assertTrue("Fehler: Element 572 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(572)); + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + assertFalse("Fehler: Element 620 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(620)); + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439}); + + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920}); + + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905}); + + assertTrue("Fehler: Element 209 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(209)); + assertTrue("Fehler: Element 143 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(143)); + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905,480}); + + dieListe.anhaengen(327); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905,480,327}); + + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905,480,327,124}); + + assertTrue("Fehler: Element 723 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(723)); + assertTrue("Fehler: Element 362 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(362)); + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{117}); + + assertFalse("Fehler: Element 732 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(732)); + assertTrue("Fehler: Element 117 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(117)); + assertTrue("Fehler: Element 117 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(117)); + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853}); + + assertFalse("Fehler: Element 384 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(384)); + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622}); + + dieListe.anhaengen(500); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500}); + + dieListe.anhaengen(284); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284}); + + dieListe.anhaengen(81); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81}); + + assertFalse("Fehler: Element 174 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(174)); + assertFalse("Fehler: Element 814 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(814)); + dieListe.anhaengen(278); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278}); + + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507}); + + dieListe.anhaengen(701); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701}); + + assertTrue("Fehler: Element 622 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(622)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709}); + + dieListe.anhaengen(756); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756}); + + assertFalse("Fehler: Element 387 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(387)); + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870}); + + assertFalse("Fehler: Element 203 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(203)); + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931}); + + assertFalse("Fehler: Element 448 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(448)); + assertFalse("Fehler: Element 373 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(373)); + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494}); + + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543}); + + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627}); + + dieListe.anhaengen(304); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304}); + + assertTrue("Fehler: Element 853 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(853)); + assertTrue("Fehler: Element 870 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(870)); + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297}); + + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788}); + + dieListe.anhaengen(55); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55}); + + assertFalse("Fehler: Element 544 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(544)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + dieListe.anhaengen(159); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159}); + + assertTrue("Fehler: Element 701 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(701)); + assertFalse("Fehler: Element 859 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(859)); + assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313)); + dieListe.anhaengen(248); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248}); + + assertFalse("Fehler: Element 739 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(739)); + dieListe.anhaengen(756); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756}); + + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383}); + + assertFalse("Fehler: Element 902 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(902)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + dieListe.anhaengen(375); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375}); + + assertTrue("Fehler: Element 55 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(55)); + assertFalse("Fehler: Element 422 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(422)); + assertTrue("Fehler: Element 452 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(452)); + dieListe.anhaengen(566); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566}); + + assertTrue("Fehler: Element 248 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(248)); + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757}); + + assertTrue("Fehler: Element 375 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(375)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + assertFalse("Fehler: Element 987 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 870 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(870)); + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470}); + + dieListe.anhaengen(385); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385}); + + dieListe.anhaengen(10); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10}); + + assertFalse("Fehler: Element 666 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(666)); + assertTrue("Fehler: Element 55 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(55)); + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417}); + + assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311)); + dieListe.anhaengen(200); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200}); + + assertTrue("Fehler: Element 10 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(10)); + dieListe.anhaengen(601); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601}); + + assertFalse("Fehler: Element 582 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(582)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709}); + + assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157)); + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + assertFalse("Fehler: Element 900 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(900)); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547}); + + dieListe.anhaengen(282); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282}); + + assertFalse("Fehler: Element 810 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(810)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + dieListe.anhaengen(433); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433}); + + dieListe.anhaengen(454); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454}); + + assertFalse("Fehler: Element 185 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(185)); + assertTrue("Fehler: Element 55 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(55)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640}); + + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640,480}); + + assertFalse("Fehler: Element 473 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(473)); + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640,480,355}); + + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + assertFalse("Fehler: Element 568 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(568)); + assertFalse("Fehler: Element 591 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(591)); + dieListe.anhaengen(375); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640,480,355,375}); + +} +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest10.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest10.java new file mode 100644 index 0000000..70acc13 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest10.java @@ -0,0 +1,2733 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest10. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest10 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(184); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + dieListe.anhaengen(90); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 90}); + + assertTrue("Fehler: Element 90 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(90)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + assertFalse("Fehler: Element 332 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(332)); + dieListe.anhaengen(911); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911}); + + dieListe.anhaengen(418); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 418}); + + dieListe.anhaengen(522); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 418, 522}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 522}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 522}); + + assertFalse("Fehler: Element 952 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(952)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + assertTrue("Fehler: Element 184 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(184)); + dieListe.einfuegenBei(1, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362, 108}); + + assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265)); + assertFalse("Fehler: Element 640 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(640)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362}); + + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362, 308}); + + dieListe.einfuegenBei(1, 627); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 627, 362, 308}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{603}); + + assertTrue("Fehler: Element 603 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(603)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(90); + Tester.pruefeListenInhalt(dieListe, new int[]{90}); + + assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(182); + Tester.pruefeListenInhalt(dieListe, new int[]{182}); + + dieListe.einfuegenBei(1, 371); + Tester.pruefeListenInhalt(dieListe, new int[]{182, 371}); + + dieListe.einfuegenBei(2, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{182, 371, 525}); + + dieListe.einfuegenBei(3, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{182, 371, 525, 380}); + + assertFalse("Fehler: Element 810 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(810)); + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{371, 525, 380}); + + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 380}); + + assertFalse("Fehler: Element 253 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(253)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{380}); + + dieListe.einfuegenBei(0, 942); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 380}); + + dieListe.anhaengen(848); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 380, 848}); + + assertTrue("Fehler: Element 380 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(380)); + assertFalse("Fehler: Element 620 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(620)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848}); + + dieListe.einfuegenBei(2, 914); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 914}); + + assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914)); + assertTrue("Fehler: Element 848 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(848)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848}); + + assertTrue("Fehler: Element 848 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(848)); + dieListe.einfuegenBei(2, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 311}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 311, 7}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 863); + Tester.pruefeListenInhalt(dieListe, new int[]{863}); + + dieListe.einfuegenBei(1, 206); + Tester.pruefeListenInhalt(dieListe, new int[]{863, 206}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{863}); + + dieListe.anhaengen(360); + Tester.pruefeListenInhalt(dieListe, new int[]{863, 360}); + + dieListe.einfuegenBei(0, 860); + Tester.pruefeListenInhalt(dieListe, new int[]{860, 863, 360}); + + assertTrue("Fehler: Element 863 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(863)); + assertTrue("Fehler: Element 863 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(863)); + assertFalse("Fehler: Element 433 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(433)); + dieListe.anhaengen(230); + Tester.pruefeListenInhalt(dieListe, new int[]{860, 863, 360, 230}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{264}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 820); + Tester.pruefeListenInhalt(dieListe, new int[]{820}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 796); + Tester.pruefeListenInhalt(dieListe, new int[]{796}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 860}); + + assertTrue("Fehler: Element 796 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(796)); + dieListe.einfuegenBei(1, 141); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 860}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141}); + + dieListe.einfuegenBei(2, 703); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703}); + + dieListe.anhaengen(376); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703, 376}); + + dieListe.einfuegenBei(2, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 536, 703, 376}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703, 376}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(587); + Tester.pruefeListenInhalt(dieListe, new int[]{587}); + + dieListe.einfuegenBei(1, 240); + Tester.pruefeListenInhalt(dieListe, new int[]{587, 240}); + + dieListe.einfuegenBei(0, 449); + Tester.pruefeListenInhalt(dieListe, new int[]{449, 587, 240}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{587, 240}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{587}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 826); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + dieListe.einfuegenBei(1, 361); + Tester.pruefeListenInhalt(dieListe, new int[]{826, 361}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + assertTrue("Fehler: Element 826 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(826)); + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{826, 100}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{23}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{296}); + + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 822}); + + dieListe.einfuegenBei(2, 149); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 822, 149}); + + dieListe.anhaengen(934); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 822, 149, 934}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 934}); + + dieListe.einfuegenBei(2, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 281, 934}); + + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 281, 934, 750}); + + dieListe.einfuegenBei(0, 594); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 296, 149, 281, 934, 750}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 296, 149, 281, 934, 750, 787}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{794}); + + dieListe.einfuegenBei(0, 18); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 794}); + + dieListe.einfuegenBei(1, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 546, 794}); + + assertTrue("Fehler: Element 546 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(546)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 794}); + + dieListe.anhaengen(984); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 794, 984}); + + assertFalse("Fehler: Element 957 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(957)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{794, 984}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{794}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{572}); + + dieListe.einfuegenBei(1, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599}); + + dieListe.anhaengen(284); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + assertFalse("Fehler: Element 817 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(817)); + assertTrue("Fehler: Element 284 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(284)); + dieListe.einfuegenBei(2, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 78, 284}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284, 529}); + + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + assertFalse("Fehler: Element 540 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(540)); + dieListe.einfuegenBei(1, 9); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 9, 599, 284}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284, 469}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 469}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469}); + + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 39}); + + dieListe.anhaengen(880); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 39, 880}); + + assertTrue("Fehler: Element 39 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(39)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 880}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 880}); + + dieListe.einfuegenBei(1, 264); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 880}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264}); + + assertFalse("Fehler: Element 225 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(225)); + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.einfuegenBei(2, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 686}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264}); + + dieListe.einfuegenBei(2, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884}); + + dieListe.anhaengen(721); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884, 721}); + + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + dieListe.anhaengen(307); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884, 721, 307}); + + dieListe.einfuegenBei(0, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 264, 884, 721, 307}); + + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 264, 721, 307}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 721, 307}); + + dieListe.einfuegenBei(1, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 82, 599, 721, 307}); + + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 82, 599, 721, 307, 531}); + + dieListe.einfuegenBei(1, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 686, 82, 599, 721, 307, 531}); + + assertTrue("Fehler: Element 307 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(307)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 407); + Tester.pruefeListenInhalt(dieListe, new int[]{407}); + + assertFalse("Fehler: Element 254 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(254)); + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 25}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 25, 262}); + + assertFalse("Fehler: Element 521 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(521)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 25, 262, 736}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 262, 736}); + + assertFalse("Fehler: Element 346 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(346)); + dieListe.einfuegenBei(1, 149); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 149, 262, 736}); + + assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736, 502}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{372}); + + assertTrue("Fehler: Element 372 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(372)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(999); + Tester.pruefeListenInhalt(dieListe, new int[]{999}); + + dieListe.anhaengen(790); + Tester.pruefeListenInhalt(dieListe, new int[]{999, 790}); + + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.einfuegenBei(0, 524); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 999, 790}); + + assertFalse("Fehler: Element 387 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(387)); + dieListe.einfuegenBei(2, 13); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 999, 13, 790}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 13, 790}); + + dieListe.einfuegenBei(1, 309); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 309, 13, 790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{309, 13, 790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{13, 790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{245}); + + dieListe.einfuegenBei(0, 517); + Tester.pruefeListenInhalt(dieListe, new int[]{517, 245}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{245}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 907); + Tester.pruefeListenInhalt(dieListe, new int[]{907}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(898); + Tester.pruefeListenInhalt(dieListe, new int[]{898}); + + assertTrue("Fehler: Element 898 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(898)); + dieListe.einfuegenBei(0, 296); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 898}); + + assertFalse("Fehler: Element 677 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(677)); + assertFalse("Fehler: Element 621 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(621)); + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 898, 777}); + + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 140); + Tester.pruefeListenInhalt(dieListe, new int[]{140}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(62); + Tester.pruefeListenInhalt(dieListe, new int[]{62}); + + assertTrue("Fehler: Element 62 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(62)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{247}); + + assertFalse("Fehler: Element 494 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(494)); + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{247, 425}); + + assertTrue("Fehler: Element 247 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(247)); + assertTrue("Fehler: Element 425 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(425)); + assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{247}); + + dieListe.anhaengen(552); + Tester.pruefeListenInhalt(dieListe, new int[]{247, 552}); + + assertFalse("Fehler: Element 295 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(295)); + assertFalse("Fehler: Element 259 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(259)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{247}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 395); + Tester.pruefeListenInhalt(dieListe, new int[]{395}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 387}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{395}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 403}); + + assertTrue("Fehler: Element 403 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(403)); + assertTrue("Fehler: Element 403 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(403)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{395}); + + dieListe.einfuegenBei(0, 223); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 395}); + + dieListe.einfuegenBei(2, 830); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 395, 830}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830}); + + assertFalse("Fehler: Element 504 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(504)); + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277}); + + assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277)); + assertTrue("Fehler: Element 830 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(830)); + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292}); + + dieListe.einfuegenBei(4, 653); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 653}); + + dieListe.einfuegenBei(4, 458); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653}); + + dieListe.anhaengen(839); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839}); + + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839, 100}); + + dieListe.anhaengen(73); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839, 100, 73}); + + assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110}); + + dieListe.einfuegenBei(9, 116); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110, 116}); + + dieListe.einfuegenBei(9, 332); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110, 332, 116}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(927); + Tester.pruefeListenInhalt(dieListe, new int[]{927}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 526}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{526}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{837}); + + assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311)); + dieListe.einfuegenBei(0, 135); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 837}); + + dieListe.einfuegenBei(1, 472); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 837}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472}); + + dieListe.anhaengen(811); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811}); + + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + dieListe.anhaengen(775); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775}); + + dieListe.einfuegenBei(4, 895); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775, 895}); + + dieListe.einfuegenBei(4, 408); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775, 408, 895}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{366}); + + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 786}); + + assertFalse("Fehler: Element 734 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(734)); + dieListe.anhaengen(598); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 786, 598}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 598}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{598}); + + dieListe.anhaengen(668); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 668}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{668}); + + dieListe.einfuegenBei(1, 344); + Tester.pruefeListenInhalt(dieListe, new int[]{668, 344}); + + assertTrue("Fehler: Element 344 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(344)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{668}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{620}); + + assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157)); + dieListe.anhaengen(389); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 389}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{620}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 72); + Tester.pruefeListenInhalt(dieListe, new int[]{72}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{152}); + + dieListe.einfuegenBei(0, 101); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152}); + + dieListe.anhaengen(753); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753}); + + dieListe.anhaengen(695); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753, 695}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753}); + + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753, 121}); + + dieListe.einfuegenBei(1, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 121}); + + dieListe.einfuegenBei(4, 47); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 47, 121}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 121}); + + dieListe.einfuegenBei(4, 453); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121}); + + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121, 349}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121, 349, 634}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 453, 121, 349, 634}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.einfuegenBei(3, 820); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634, 515}); + + dieListe.anhaengen(715); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634, 515, 715}); + + dieListe.einfuegenBei(6, 378); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 378, 349, 634, 515, 715}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 453, 121, 378, 349, 634, 515, 715}); + + dieListe.einfuegenBei(6, 73); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 453, 121, 378, 73, 349, 634, 515, 715}); + + dieListe.einfuegenBei(3, 0); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 0, 453, 121, 378, 73, 349, 634, 515, 715}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{434}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{434, 157}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{434, 157, 387}); + + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{434, 157, 387, 306}); + + assertTrue("Fehler: Element 387 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(387)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306}); + + assertFalse("Fehler: Element 922 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(922)); + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306, 625}); + + dieListe.einfuegenBei(3, 751); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306, 751, 625}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 625}); + + assertFalse("Fehler: Element 498 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(498)); + assertFalse("Fehler: Element 782 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(782)); + dieListe.anhaengen(438); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 625, 438}); + + dieListe.einfuegenBei(3, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 758, 625, 438}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 758, 625}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 758, 625}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 625}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758}); + + dieListe.anhaengen(584); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 584}); + + dieListe.anhaengen(616); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 584, 616}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616}); + + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.einfuegenBei(3, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652}); + + assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157)); + assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644)); + assertFalse("Fehler: Element 301 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(301)); + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660}); + + dieListe.einfuegenBei(5, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660, 880}); + + assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407)); + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660, 880, 711}); + + dieListe.einfuegenBei(2, 176); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711}); + + dieListe.anhaengen(803); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711, 803}); + + assertTrue("Fehler: Element 660 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(660)); + assertFalse("Fehler: Element 573 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(573)); + dieListe.anhaengen(63); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711, 803, 63}); + + dieListe.einfuegenBei(4, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 525, 652, 660, 880, 711, 803, 63}); + + dieListe.einfuegenBei(0, 50); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 880, 711, 803, 63}); + + assertTrue("Fehler: Element 711 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(711)); + dieListe.einfuegenBei(8, 695); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63}); + + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605}); + + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983}); + + assertTrue("Fehler: Element 880 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(880)); + assertFalse("Fehler: Element 224 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(224)); + dieListe.einfuegenBei(0, 535); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983}); + + assertFalse("Fehler: Element 14 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(14)); + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.anhaengen(800); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983, 800}); + + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983, 800, 699}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 800, 699}); + + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964}); + + assertFalse("Fehler: Element 632 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(632)); + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964, 699}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964, 699}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 803, 63, 605, 800, 699, 964, 699}); + + dieListe.einfuegenBei(12, 210); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 803, 63, 605, 210, 800, 699, 964, 699}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{778}); + + dieListe.einfuegenBei(0, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 778}); + + assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778)); + assertTrue("Fehler: Element 91 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(91)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{91}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(987); + Tester.pruefeListenInhalt(dieListe, new int[]{987}); + + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + assertFalse("Fehler: Element 556 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(556)); + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + dieListe.einfuegenBei(2, 337); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337}); + + assertTrue("Fehler: Element 337 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(337)); + dieListe.einfuegenBei(3, 877); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337, 877}); + + dieListe.einfuegenBei(4, 50); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337, 877, 50}); + + dieListe.einfuegenBei(1, 987); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 337, 877, 50}); + + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 337, 50}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50}); + + dieListe.anhaengen(666); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 666}); + + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50}); + + assertFalse("Fehler: Element 925 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(925)); + dieListe.einfuegenBei(4, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 788}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 788, 194}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 194}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 50, 194}); + + dieListe.einfuegenBei(4, 451); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 50, 194, 451}); + + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 50, 194, 451}); + + dieListe.einfuegenBei(2, 260); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 50, 260, 194, 451}); + + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 260, 194, 451}); + + dieListe.einfuegenBei(1, 248); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 248, 260, 194, 451}); + + dieListe.einfuegenBei(1, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 380, 248, 260, 194, 451}); + + dieListe.anhaengen(13); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 380, 248, 260, 194, 451, 13}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 948); + Tester.pruefeListenInhalt(dieListe, new int[]{948}); + + dieListe.einfuegenBei(1, 800); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 800}); + + dieListe.einfuegenBei(0, 881); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 948, 800}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800}); + + assertTrue("Fehler: Element 881 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(881)); + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 568}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800}); + + dieListe.einfuegenBei(2, 734); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 734}); + + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 734, 166}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 166}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 166, 974}); + + dieListe.einfuegenBei(1, 814); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 800, 166, 974}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 800, 166}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 166}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 166}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{166}); + + dieListe.einfuegenBei(1, 801); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 801}); + + assertFalse("Fehler: Element 564 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(564)); + dieListe.einfuegenBei(1, 727); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801}); + + assertFalse("Fehler: Element 503 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(503)); + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801, 623}); + + dieListe.anhaengen(58); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801, 623, 58}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{453}); + + dieListe.einfuegenBei(0, 517); + Tester.pruefeListenInhalt(dieListe, new int[]{517, 453}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{132}); + + dieListe.einfuegenBei(0, 623); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 132}); + + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.einfuegenBei(1, 387); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 132}); + + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 132, 518}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 359}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 359, 845}); + + dieListe.einfuegenBei(3, 177); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 177, 359, 845}); + + assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477)); + dieListe.einfuegenBei(4, 191); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 177, 191, 359, 845}); + + assertTrue("Fehler: Element 177 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(177)); + assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725)); + dieListe.einfuegenBei(0, 837); + Tester.pruefeListenInhalt(dieListe, new int[]{837, 623, 387, 518, 177, 191, 359, 845}); + + assertTrue("Fehler: Element 359 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(359)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{837, 623, 387, 518, 177, 359, 845}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{936}); + + dieListe.anhaengen(0); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0}); + + dieListe.einfuegenBei(2, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 588}); + + assertFalse("Fehler: Element 470 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(470)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0}); + + dieListe.anhaengen(87); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87}); + + assertFalse("Fehler: Element 784 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(784)); + dieListe.anhaengen(872); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87, 872}); + + assertFalse("Fehler: Element 955 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(955)); + dieListe.einfuegenBei(3, 964); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87, 964, 872}); + + assertTrue("Fehler: Element 0 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(0)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872}); + + dieListe.einfuegenBei(4, 516); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872, 516}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872, 516, 22}); + + dieListe.einfuegenBei(3, 649); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 649, 872, 516, 22}); + + dieListe.anhaengen(93); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 649, 872, 516, 22, 93}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{828}); + + dieListe.einfuegenBei(1, 113); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 113}); + + assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485)); + assertFalse("Fehler: Element 227 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(227)); + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 113, 306}); + + dieListe.einfuegenBei(2, 27); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 113, 27, 306}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 306}); + + dieListe.anhaengen(28); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 306, 28}); + + assertTrue("Fehler: Element 828 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(828)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28}); + + dieListe.einfuegenBei(3, 511); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28, 511}); + + assertTrue("Fehler: Element 28 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(28)); + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28, 511, 749}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749}); + + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749, 603}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749}); + + dieListe.einfuegenBei(2, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749}); + + dieListe.anhaengen(331); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837}); + + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837, 353}); + + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + dieListe.anhaengen(456); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837, 353, 456}); + + assertTrue("Fehler: Element 456 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(456)); + dieListe.einfuegenBei(0, 524); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 511, 749, 331, 837, 353, 456}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 837, 353, 456}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456}); + + assertTrue("Fehler: Element 28 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(28)); + assertTrue("Fehler: Element 353 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(353)); + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456, 707}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 331, 353, 456}); + + assertTrue("Fehler: Element 524 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(524)); + assertTrue("Fehler: Element 353 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(353)); + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 331, 353, 456, 264}); + + dieListe.einfuegenBei(1, 119); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264}); + + assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482)); + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264, 127}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{154}); + + dieListe.einfuegenBei(0, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 154}); + + dieListe.einfuegenBei(0, 253); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154}); + + assertTrue("Fehler: Element 253 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(253)); + dieListe.anhaengen(282); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 282}); + + assertFalse("Fehler: Element 704 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(704)); + dieListe.einfuegenBei(3, 692); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692, 282}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692}); + + assertFalse("Fehler: Element 862 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(862)); + assertTrue("Fehler: Element 253 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(253)); + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.anhaengen(587); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692, 587}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 587}); + + assertFalse("Fehler: Element 818 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(818)); + assertFalse("Fehler: Element 878 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(878)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 587}); + + assertFalse("Fehler: Element 293 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(293)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 587}); + + assertFalse("Fehler: Element 527 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(527)); + assertTrue("Fehler: Element 587 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(587)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{587}); + + dieListe.einfuegenBei(0, 528); + Tester.pruefeListenInhalt(dieListe, new int[]{528, 587}); + + assertFalse("Fehler: Element 634 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(634)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{175}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 268); + Tester.pruefeListenInhalt(dieListe, new int[]{268}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(239); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(1, 705); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 705}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 77}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 461}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(0, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 239}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{396}); + + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 749}); + + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{396}); + + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + dieListe.einfuegenBei(1, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220}); + + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969}); + + dieListe.anhaengen(739); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969, 739}); + + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969, 739, 846}); + + dieListe.einfuegenBei(2, 784); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846}); + + dieListe.anhaengen(696); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846, 696}); + + dieListe.anhaengen(509); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846, 696, 509}); + + assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 509}); + + dieListe.anhaengen(44); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 509, 44}); + + assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 44}); + + assertFalse("Fehler: Element 881 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(881)); + dieListe.anhaengen(947); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 44, 947}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 784, 739, 846, 696, 44, 947}); + + dieListe.einfuegenBei(0, 287); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 396, 784, 739, 846, 696, 44, 947}); + + dieListe.einfuegenBei(6, 982); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 396, 784, 739, 846, 696, 982, 44, 947}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 846, 696, 982, 44, 947}); + + dieListe.einfuegenBei(3, 226); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 226, 846, 696, 982, 44, 947}); + + dieListe.einfuegenBei(2, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 696, 982, 44, 947}); + + dieListe.anhaengen(390); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 696, 982, 44, 947, 390}); + + dieListe.einfuegenBei(6, 850); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 696, 982, 44, 947, 390}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 696, 982, 44, 947}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 982, 44, 947}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 226, 846, 850, 982, 44, 947}); + + assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 846, 850, 982, 44, 947}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947}); + + dieListe.einfuegenBei(2, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 467, 226, 850, 982, 44, 947}); + + assertFalse("Fehler: Element 512 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(512)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947, 351}); + + dieListe.einfuegenBei(2, 644); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 644, 226, 850, 982, 44, 947, 351}); + + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + assertTrue("Fehler: Element 287 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(287)); + dieListe.einfuegenBei(1, 594); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 739, 644, 226, 850, 982, 44, 947, 351}); + + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 739, 644, 226, 850, 982, 44, 947, 351, 940}); + + dieListe.einfuegenBei(2, 531); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940}); + + dieListe.anhaengen(544); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544}); + + assertFalse("Fehler: Element 35 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(35)); + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544, 409}); + + assertFalse("Fehler: Element 523 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(523)); + assertTrue("Fehler: Element 940 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(940)); + dieListe.einfuegenBei(13, 257); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544, 257, 409}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 947, 351, 940, 544, 257, 409}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 982, 947, 351, 940, 544, 257, 409}); + + assertTrue("Fehler: Element 226 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(226)); + assertFalse("Fehler: Element 717 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(717)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 982, 947, 351, 940, 257, 409}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 947, 351, 940, 257, 409}); + + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 947, 351, 940, 257, 409, 37}); + + dieListe.einfuegenBei(3, 28); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 28, 739, 644, 226, 947, 351, 940, 257, 409, 37}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 28, 739, 644, 947, 351, 940, 257, 409, 37}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{547}); + + dieListe.einfuegenBei(1, 385); + Tester.pruefeListenInhalt(dieListe, new int[]{547, 385}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{547}); + + assertFalse("Fehler: Element 189 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(189)); + assertTrue("Fehler: Element 547 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(547)); + dieListe.einfuegenBei(1, 346); + Tester.pruefeListenInhalt(dieListe, new int[]{547, 346}); + + dieListe.anhaengen(142); + Tester.pruefeListenInhalt(dieListe, new int[]{547, 346, 142}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 142}); + + assertTrue("Fehler: Element 346 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(346)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{142}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920}); + + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 857}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920}); + + dieListe.anhaengen(715); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715, 964}); + + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(516); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715, 964, 516}); + + assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964)); + dieListe.einfuegenBei(1, 171); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 920, 715, 964, 516}); + + dieListe.einfuegenBei(2, 48); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 48, 920, 715, 964, 516}); + + dieListe.einfuegenBei(4, 256); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 48, 920, 256, 715, 964, 516}); + + dieListe.einfuegenBei(0, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 964, 516}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 516}); + + assertTrue("Fehler: Element 715 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(715)); + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 516, 725}); + + dieListe.einfuegenBei(1, 295); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516, 725}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516}); + + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516, 355}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 516, 355}); + + assertFalse("Fehler: Element 930 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(930)); + assertFalse("Fehler: Element 934 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(934)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355}); + + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + dieListe.anhaengen(412); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355, 412}); + + dieListe.anhaengen(823); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355, 412, 823}); + + dieListe.einfuegenBei(6, 150); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823}); + + dieListe.anhaengen(13); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484}); + + dieListe.anhaengen(493); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493}); + + dieListe.anhaengen(74); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493, 74}); + + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertTrue("Fehler: Element 150 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(150)); + dieListe.anhaengen(489); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489}); + + dieListe.einfuegenBei(6, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489, 417}); + + assertFalse("Fehler: Element 456 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(456)); + dieListe.anhaengen(702); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489, 417, 702}); + + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + dieListe.einfuegenBei(16, 947); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 417, 702}); + + dieListe.entferneBei(18); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 702}); + + dieListe.einfuegenBei(5, 573); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 702}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.einfuegenBei(6, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 794, 920, 238, 150, 256, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.anhaengen(420); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420}); + + assertFalse("Fehler: Element 723 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(723)); + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420, 207}); + + assertTrue("Fehler: Element 207 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(207)); + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + dieListe.anhaengen(70); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420, 207, 70}); + + assertTrue("Fehler: Element 412 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(412)); + dieListe.einfuegenBei(13, 373); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.einfuegenBei(11, 825); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.einfuegenBei(1, 170); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70, 450}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70, 450}); + + dieListe.entferneBei(19); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196}); + + dieListe.einfuegenBei(9, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196}); + + dieListe.einfuegenBei(5, 335); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196}); + + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935}); + + assertTrue("Fehler: Element 420 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(420)); + assertTrue("Fehler: Element 295 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(295)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441}); + + dieListe.einfuegenBei(2, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441}); + + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + dieListe.anhaengen(558); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558}); + + dieListe.einfuegenBei(1, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + assertFalse("Fehler: Element 111 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(111)); + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558, 369}); + + dieListe.anhaengen(209); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558, 369, 209}); + + dieListe.einfuegenBei(23, 243); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.einfuegenBei(19, 523); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 825, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.einfuegenBei(4, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 144, 295, 171, 335, 920, 412, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + assertFalse("Fehler: Element 121 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(121)); + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + dieListe.anhaengen(48); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209, 48}); + + dieListe.einfuegenBei(16, 365); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 365, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209, 48}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{842}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{767}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 846); + Tester.pruefeListenInhalt(dieListe, new int[]{846}); + + dieListe.anhaengen(433); + Tester.pruefeListenInhalt(dieListe, new int[]{846, 433}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{433}); + + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 466}); + + dieListe.anhaengen(701); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 466, 701}); + + dieListe.einfuegenBei(1, 40); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701, 465}); + + dieListe.einfuegenBei(0, 121); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 433, 40, 466, 701, 465}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701, 465}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 466, 701, 465}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465}); + + dieListe.anhaengen(94); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94}); + + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660}); + + assertFalse("Fehler: Element 31 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(31)); + dieListe.anhaengen(728); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660, 728}); + + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660, 728, 683}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 728, 683}); + + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 728, 683, 15}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 94, 728, 683, 15}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 15}); + + dieListe.anhaengen(384); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 15, 384}); + + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + assertTrue("Fehler: Element 683 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(683)); + assertTrue("Fehler: Element 728 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(728)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 384}); + + dieListe.einfuegenBei(1, 182); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 182, 701, 728, 683, 384}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 384}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 683, 384}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 683, 384, 211}); + + dieListe.einfuegenBei(2, 916); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 916, 683, 384, 211}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211, 450}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 683, 384, 211}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(916); + Tester.pruefeListenInhalt(dieListe, new int[]{916}); + + dieListe.anhaengen(598); + Tester.pruefeListenInhalt(dieListe, new int[]{916, 598}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{598}); + + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + dieListe.einfuegenBei(1, 161); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 161}); + + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + dieListe.einfuegenBei(1, 483); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 483, 161}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 483}); + + assertTrue("Fehler: Element 483 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(483)); + dieListe.anhaengen(370); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 483, 370}); + + assertFalse("Fehler: Element 266 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(266)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370}); + + dieListe.anhaengen(497); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 497}); + + assertTrue("Fehler: Element 497 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(497)); + dieListe.einfuegenBei(2, 273); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 273, 497}); + + dieListe.einfuegenBei(2, 650); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497, 593}); + + dieListe.einfuegenBei(6, 51); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497, 593, 51}); + + dieListe.einfuegenBei(3, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 497, 593, 51}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 497, 593, 51, 581}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 593, 51, 581}); + + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 51, 581}); + + dieListe.anhaengen(514); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 51, 581, 514}); + + assertFalse("Fehler: Element 80 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(80)); + dieListe.einfuegenBei(3, 930); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 581, 514}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 581, 514, 23}); + + dieListe.einfuegenBei(7, 375); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23}); + + dieListe.anhaengen(478); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23, 478}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23, 478, 793}); + + assertTrue("Fehler: Element 514 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(514)); + dieListe.einfuegenBei(9, 303); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 303, 514, 23, 478, 793}); + + assertFalse("Fehler: Element 747 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(747)); + dieListe.einfuegenBei(11, 379); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 303, 514, 379, 23, 478, 793}); + + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 581, 303, 514, 379, 23, 478, 793}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793}); + + dieListe.anhaengen(789); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789}); + + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789, 37}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789, 37, 727}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 478, 793, 789, 37, 727}); + + assertTrue("Fehler: Element 727 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(727)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 793, 789, 37, 727}); + + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 793, 789, 37, 727, 37}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 303, 514, 23, 793, 789, 37, 727, 37}); + + dieListe.anhaengen(741); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 303, 514, 23, 793, 789, 37, 727, 37, 741}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{280}); + + dieListe.einfuegenBei(0, 744); + Tester.pruefeListenInhalt(dieListe, new int[]{744, 280}); + + dieListe.einfuegenBei(1, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{744, 382, 280}); + + assertTrue("Fehler: Element 744 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(744)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{382, 280}); + + assertTrue("Fehler: Element 280 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(280)); + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{382, 280, 194}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 932); + Tester.pruefeListenInhalt(dieListe, new int[]{932}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 441); + Tester.pruefeListenInhalt(dieListe, new int[]{441}); + + dieListe.anhaengen(248); + Tester.pruefeListenInhalt(dieListe, new int[]{441, 248}); + + assertTrue("Fehler: Element 441 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(441)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{248}); + + assertFalse("Fehler: Element 594 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(594)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{676}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(150); + Tester.pruefeListenInhalt(dieListe, new int[]{150}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{932}); + + dieListe.anhaengen(942); + Tester.pruefeListenInhalt(dieListe, new int[]{932, 942}); + + dieListe.einfuegenBei(0, 162); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 932, 942}); + + dieListe.einfuegenBei(3, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 932, 942, 778}); + + assertFalse("Fehler: Element 241 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(241)); + dieListe.einfuegenBei(1, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366}); + + assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76)); + dieListe.einfuegenBei(6, 134); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134}); + + assertTrue("Fehler: Element 134 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(134)); + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + dieListe.einfuegenBei(7, 464); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134, 464}); + + dieListe.anhaengen(910); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134, 464, 910}); + + assertFalse("Fehler: Element 822 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(822)); + assertFalse("Fehler: Element 638 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(638)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 134, 464, 910}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 464, 910}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + dieListe.anhaengen(755); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 755}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910}); + + dieListe.einfuegenBei(6, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82}); + + assertTrue("Fehler: Element 910 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(910)); + dieListe.anhaengen(164); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82, 164}); + + dieListe.anhaengen(916); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82, 164, 916}); + + assertFalse("Fehler: Element 149 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(149)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916}); + + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916, 777}); + + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916, 777, 618}); + + assertFalse("Fehler: Element 928 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(928)); + dieListe.einfuegenBei(6, 356); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 164, 916, 777, 618}); + + dieListe.einfuegenBei(7, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 239, 164, 916, 777, 618}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 239, 164, 916, 777}); + + assertTrue("Fehler: Element 95 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(95)); + assertTrue("Fehler: Element 777 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(777)); + dieListe.einfuegenBei(7, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 311, 239, 164, 916, 777}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 311, 239, 164, 916, 777, 774}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{787}); + + assertTrue("Fehler: Element 787 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(787)); + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 750}); + + dieListe.einfuegenBei(2, 158); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 158, 750}); + + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 158, 750, 645}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{196}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{117}); + + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{117, 937}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{117}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 485); + Tester.pruefeListenInhalt(dieListe, new int[]{485}); + + assertTrue("Fehler: Element 485 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(485)); + dieListe.einfuegenBei(0, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 485}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{481}); + + assertFalse("Fehler: Element 898 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(898)); + dieListe.einfuegenBei(1, 285); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 285}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{285}); + + dieListe.anhaengen(133); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133}); + + dieListe.anhaengen(444); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444}); + + assertTrue("Fehler: Element 133 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(133)); + assertFalse("Fehler: Element 393 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(393)); + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + dieListe.einfuegenBei(3, 276); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444, 276}); + + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444, 276, 213}); + + assertFalse("Fehler: Element 891 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(891)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 276, 213}); + + assertFalse("Fehler: Element 764 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(764)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 276, 213}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{276, 213}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{213}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 251); + Tester.pruefeListenInhalt(dieListe, new int[]{251}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 745); + Tester.pruefeListenInhalt(dieListe, new int[]{745}); + + assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745)); + assertFalse("Fehler: Element 233 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(233)); + assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745)); + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562}); + + dieListe.anhaengen(447); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 447}); + + dieListe.einfuegenBei(2, 274); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447, 620}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447}); + + dieListe.einfuegenBei(2, 779); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 779, 274, 447}); + + assertTrue("Fehler: Element 447 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(447)); + dieListe.einfuegenBei(2, 118); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 118, 779, 274, 447}); + + assertFalse("Fehler: Element 494 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(494)); + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 903); + Tester.pruefeListenInhalt(dieListe, new int[]{903}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{665}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{605}); + + dieListe.einfuegenBei(0, 446); + Tester.pruefeListenInhalt(dieListe, new int[]{446, 605}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{605}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{900}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{59}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.anhaengen(350); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350, 180}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350, 853}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853}); + + dieListe.anhaengen(311); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 311}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 634}); + + dieListe.einfuegenBei(2, 243); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 243, 634}); + + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 243, 634, 740}); + + assertFalse("Fehler: Element 11 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(11)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 243, 634, 740}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740}); + + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740, 861}); + + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740, 861, 828}); + + assertFalse("Fehler: Element 837 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(837)); + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + dieListe.einfuegenBei(0, 664); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 350, 634, 740, 861, 828}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 634, 740, 861, 828}); + + assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 861, 828}); + + dieListe.anhaengen(519); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 861, 828, 519}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 828, 519}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{740, 828, 519}); + + dieListe.einfuegenBei(0, 627); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 828, 519}); + + dieListe.einfuegenBei(2, 518); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 518, 828, 519}); + + assertTrue("Fehler: Element 519 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(519)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 518, 828}); + + dieListe.einfuegenBei(0, 443); + Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 740, 518, 828}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 518, 828}); + + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + dieListe.einfuegenBei(2, 280); + Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 280, 518, 828}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{425}); + + dieListe.einfuegenBei(1, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 436}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 436, 637}); + + dieListe.einfuegenBei(0, 410); + Tester.pruefeListenInhalt(dieListe, new int[]{410, 425, 436, 637}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 436, 637}); + + dieListe.einfuegenBei(1, 656); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 656, 436, 637}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 61); + Tester.pruefeListenInhalt(dieListe, new int[]{61}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{502}); + + dieListe.einfuegenBei(1, 94); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 94}); + + dieListe.einfuegenBei(0, 755); + Tester.pruefeListenInhalt(dieListe, new int[]{755, 502, 94}); + + dieListe.einfuegenBei(2, 542); + Tester.pruefeListenInhalt(dieListe, new int[]{755, 502, 542, 94}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 542, 94}); + + assertFalse("Fehler: Element 675 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(675)); + assertTrue("Fehler: Element 502 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(502)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 94}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 94, 869}); + + dieListe.einfuegenBei(1, 305); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 305, 94, 869}); + + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 305, 94, 869, 970}); + + assertTrue("Fehler: Element 94 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(94)); + assertTrue("Fehler: Element 94 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(94)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{305, 94, 869, 970}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 970}); + + assertTrue("Fehler: Element 970 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(970)); + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 970, 280}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 280}); + + dieListe.anhaengen(498); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 280, 498}); + + dieListe.einfuegenBei(0, 967); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 94, 869, 280, 498}); + + dieListe.einfuegenBei(1, 124); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 94, 869, 280, 498}); + + dieListe.einfuegenBei(2, 761); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 761, 94, 869, 280, 498}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 761, 94, 869, 280, 498, 157}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{105}); + + dieListe.anhaengen(59); + Tester.pruefeListenInhalt(dieListe, new int[]{105, 59}); + + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{59}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{719}); + + dieListe.einfuegenBei(0, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719}); + + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 487}); + + assertTrue("Fehler: Element 427 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(427)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719}); + + dieListe.einfuegenBei(1, 87); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 87, 719}); + + dieListe.anhaengen(249); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 87, 719, 249}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 249}); + + dieListe.anhaengen(215); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 249, 215}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{719, 249, 215}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest2.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest2.java new file mode 100644 index 0000000..071e274 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest2.java @@ -0,0 +1,2033 @@ +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 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 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 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 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 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 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 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 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 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 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)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest3.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest3.java new file mode 100644 index 0000000..96d041b --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest3.java @@ -0,0 +1,2095 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest3. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest3 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{100}); + + dieListe.anhaengen(544); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544}); + + assertFalse("Fehler: Element 588 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(588)); + assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + dieListe.anhaengen(162); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162}); + + dieListe.anhaengen(238); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69}); + + assertTrue("Fehler: Element 162 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(162)); + assertTrue("Fehler: Element 544 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(544)); + assertTrue("Fehler: Element 238 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(238)); + assertTrue("Fehler: Element 69 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(69)); + dieListe.anhaengen(525); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525}); + + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.anhaengen(565); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565}); + + dieListe.anhaengen(638); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638}); + + assertFalse("Fehler: Element 786 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(786)); + dieListe.anhaengen(561); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561}); + + dieListe.anhaengen(773); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773}); + + dieListe.anhaengen(872); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872}); + + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(802); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502}); + + dieListe.anhaengen(81); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81}); + + dieListe.anhaengen(78); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78}); + + assertTrue("Fehler: Element 638 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(638)); + dieListe.anhaengen(934); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934}); + + dieListe.anhaengen(111); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111}); + + dieListe.anhaengen(342); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413}); + + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + assertTrue("Fehler: Element 565 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(565)); + dieListe.anhaengen(517); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517}); + + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178}); + + assertFalse("Fehler: Element 890 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(890)); + assertFalse("Fehler: Element 289 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(289)); + dieListe.anhaengen(506); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506}); + + assertTrue("Fehler: Element 802 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(884); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219}); + + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998}); + + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168}); + + assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76)); + dieListe.anhaengen(564); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564}); + + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 525 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(525)); + assertTrue("Fehler: Element 506 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(506)); + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869}); + + assertFalse("Fehler: Element 74 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(74)); + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + assertTrue("Fehler: Element 111 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(111)); + assertTrue("Fehler: Element 802 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(130); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620}); + + assertFalse("Fehler: Element 769 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(769)); + assertFalse("Fehler: Element 459 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(459)); + assertFalse("Fehler: Element 484 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(484)); + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + assertTrue("Fehler: Element 564 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(564)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45}); + + dieListe.anhaengen(695); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertFalse("Fehler: Element 786 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(786)); + assertFalse("Fehler: Element 71 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(71)); + assertTrue("Fehler: Element 342 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(342)); + assertTrue("Fehler: Element 638 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(638)); + assertTrue("Fehler: Element 81 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(81)); + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122}); + + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368}); + + assertFalse("Fehler: Element 586 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(586)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + assertFalse("Fehler: Element 160 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(160)); + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828}); + + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862}); + + dieListe.anhaengen(810); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810}); + + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499}); + + assertTrue("Fehler: Element 561 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(561)); + assertFalse("Fehler: Element 563 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(563)); + assertFalse("Fehler: Element 747 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(747)); + dieListe.anhaengen(668); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668}); + + assertTrue("Fehler: Element 342 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(342)); + dieListe.anhaengen(193); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668, 193}); + + assertFalse("Fehler: Element 722 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(722)); + assertFalse("Fehler: Element 860 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(860)); + dieListe.anhaengen(930); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668, 193, 930}); + + assertFalse("Fehler: Element 266 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(266)); + assertTrue("Fehler: Element 773 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(773)); + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668, 193, 930, 110}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(428); + Tester.pruefeListenInhalt(dieListe, new int[]{428}); + + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972}); + + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481}); + + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783}); + + assertFalse("Fehler: Element 735 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(735)); + assertTrue("Fehler: Element 972 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(972)); + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + assertFalse("Fehler: Element 99 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(99)); + dieListe.anhaengen(901); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + assertFalse("Fehler: Element 398 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(398)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583}); + + assertTrue("Fehler: Element 783 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(783)); + assertFalse("Fehler: Element 822 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(822)); + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333}); + + assertFalse("Fehler: Element 108 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(108)); + assertFalse("Fehler: Element 989 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937}); + + dieListe.anhaengen(520); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520}); + + assertFalse("Fehler: Element 270 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(270)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertFalse("Fehler: Element 453 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(453)); + dieListe.anhaengen(599); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599}); + + dieListe.anhaengen(147); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 783 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(783)); + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618}); + + dieListe.anhaengen(523); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523}); + + dieListe.anhaengen(98); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98}); + + dieListe.anhaengen(766); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766}); + + dieListe.anhaengen(960); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593}); + + dieListe.anhaengen(985); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985}); + + dieListe.anhaengen(458); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458}); + + assertTrue("Fehler: Element 147 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(147)); + assertTrue("Fehler: Element 402 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(402)); + assertTrue("Fehler: Element 797 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(797)); + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881}); + + dieListe.anhaengen(813); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813}); + + assertTrue("Fehler: Element 458 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(458)); + dieListe.anhaengen(42); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42}); + + assertFalse("Fehler: Element 990 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(990)); + assertTrue("Fehler: Element 937 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(937)); + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527}); + + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581}); + + dieListe.anhaengen(805); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453}); + + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688}); + + assertTrue("Fehler: Element 382 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(382)); + assertFalse("Fehler: Element 931 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(931)); + assertFalse("Fehler: Element 267 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(267)); + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127}); + + assertFalse("Fehler: Element 930 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(930)); + assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718)); + assertFalse("Fehler: Element 981 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(981)); + dieListe.anhaengen(809); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809}); + + assertTrue("Fehler: Element 813 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(813)); + assertTrue("Fehler: Element 813 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(813)); + dieListe.anhaengen(253); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253}); + + assertTrue("Fehler: Element 458 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(458)); + dieListe.anhaengen(652); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285}); + + dieListe.anhaengen(643); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643}); + + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283}); + + dieListe.anhaengen(643); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643}); + + dieListe.anhaengen(917); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917}); + + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293}); + + assertTrue("Fehler: Element 813 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(813)); + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(14); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14}); + + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 901 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(901)); + dieListe.anhaengen(950); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392}); + + assertFalse("Fehler: Element 169 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(169)); + dieListe.anhaengen(734); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734}); + + assertTrue("Fehler: Element 402 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(402)); + assertTrue("Fehler: Element 127 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(127)); + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213}); + + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992}); + + dieListe.anhaengen(339); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339}); + + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339, 777}); + + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339, 777, 314}); + + assertTrue("Fehler: Element 643 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(643)); + assertTrue("Fehler: Element 285 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(285)); + dieListe.anhaengen(855); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339, 777, 314, 855}); + + assertFalse("Fehler: Element 775 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(775)); + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{589}); + + assertFalse("Fehler: Element 27 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(27)); + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + assertTrue("Fehler: Element 757 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(757)); + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576}); + + assertFalse("Fehler: Element 464 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(464)); + dieListe.anhaengen(42); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526}); + + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302}); + + assertFalse("Fehler: Element 232 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(232)); + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581}); + + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + assertFalse("Fehler: Element 515 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(515)); + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618}); + + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(945); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945}); + + dieListe.anhaengen(714); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305}); + + assertFalse("Fehler: Element 55 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(55)); + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + assertFalse("Fehler: Element 976 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(5); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5}); + + assertTrue("Fehler: Element 731 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(731)); + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452}); + + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(462); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462}); + + assertFalse("Fehler: Element 900 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(900)); + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518}); + + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83}); + + dieListe.anhaengen(460); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460}); + + assertFalse("Fehler: Element 737 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(737)); + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547}); + + dieListe.anhaengen(843); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843}); + + dieListe.anhaengen(164); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164}); + + assertTrue("Fehler: Element 419 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(419)); + dieListe.anhaengen(479); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479}); + + dieListe.anhaengen(590); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590}); + + assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358)); + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954}); + + dieListe.anhaengen(325); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325}); + + dieListe.anhaengen(839); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839}); + + assertTrue("Fehler: Element 479 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(479)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(794); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + dieListe.anhaengen(363); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363}); + + assertTrue("Fehler: Element 325 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(325)); + assertFalse("Fehler: Element 62 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(62)); + assertTrue("Fehler: Element 518 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(518)); + assertFalse("Fehler: Element 444 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(444)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688}); + + assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302)); + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329}); + + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + assertFalse("Fehler: Element 698 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(698)); + dieListe.anhaengen(338); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338}); + + dieListe.anhaengen(947); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947}); + + assertTrue("Fehler: Element 714 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(714)); + dieListe.anhaengen(751); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247}); + + assertTrue("Fehler: Element 460 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(460)); + assertFalse("Fehler: Element 31 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(31)); + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637}); + + dieListe.anhaengen(360); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360}); + + assertTrue("Fehler: Element 325 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(325)); + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + dieListe.anhaengen(403); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727}); + + assertTrue("Fehler: Element 462 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(462)); + assertTrue("Fehler: Element 5 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(5)); + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108}); + + dieListe.anhaengen(981); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981}); + + assertTrue("Fehler: Element 305 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(305)); + assertTrue("Fehler: Element 714 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(714)); + assertFalse("Fehler: Element 106 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(106)); + dieListe.anhaengen(176); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176}); + + dieListe.anhaengen(747); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747}); + + dieListe.anhaengen(63); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63}); + + assertFalse("Fehler: Element 635 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(635)); + assertTrue("Fehler: Element 479 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(479)); + assertTrue("Fehler: Element 981 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(981)); + dieListe.anhaengen(174); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63, 174}); + + assertFalse("Fehler: Element 38 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(38)); + assertTrue("Fehler: Element 42 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(42)); + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.anhaengen(435); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63, 174, 435}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63, 174, 435, 704}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{440}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392}); + + assertTrue("Fehler: Element 440 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(440)); + dieListe.anhaengen(394); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394}); + + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + assertTrue("Fehler: Element 440 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(440)); + assertFalse("Fehler: Element 859 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(859)); + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583}); + + assertFalse("Fehler: Element 7 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(7)); + assertFalse("Fehler: Element 31 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(31)); + dieListe.anhaengen(64); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64}); + + dieListe.anhaengen(17); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180}); + + assertFalse("Fehler: Element 907 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(907)); + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765)); + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + dieListe.anhaengen(537); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537}); + + assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(705); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705}); + + assertFalse("Fehler: Element 356 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(356)); + assertTrue("Fehler: Element 705 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(705)); + assertFalse("Fehler: Element 679 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(679)); + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40}); + + dieListe.anhaengen(887); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887}); + + dieListe.anhaengen(887); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846}); + + assertTrue("Fehler: Element 17 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(17)); + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675}); + + dieListe.anhaengen(173); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528}); + + dieListe.anhaengen(431); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431}); + + assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(600); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600}); + + assertTrue("Fehler: Element 180 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(180)); + assertTrue("Fehler: Element 600 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(600)); + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207}); + + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712}); + + assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + assertTrue("Fehler: Element 600 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(600)); + dieListe.anhaengen(24); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24}); + + assertFalse("Fehler: Element 397 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(397)); + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704}); + + assertFalse("Fehler: Element 324 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(324)); + assertFalse("Fehler: Element 354 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(354)); + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357}); + + assertFalse("Fehler: Element 532 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(532)); + assertFalse("Fehler: Element 598 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(598)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 537 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(537)); + assertFalse("Fehler: Element 145 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(145)); + dieListe.anhaengen(316); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316}); + + dieListe.anhaengen(112); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112}); + + assertFalse("Fehler: Element 981 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(981)); + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + dieListe.anhaengen(617); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617}); + + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + assertFalse("Fehler: Element 340 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(340)); + assertTrue("Fehler: Element 357 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(357)); + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955}); + + assertFalse("Fehler: Element 877 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(877)); + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535}); + + dieListe.anhaengen(864); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864}); + + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627}); + + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670}); + + assertFalse("Fehler: Element 753 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(753)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertFalse("Fehler: Element 746 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(746)); + assertFalse("Fehler: Element 684 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(684)); + dieListe.anhaengen(834); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834}); + + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123}); + + dieListe.anhaengen(573); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573}); + + assertTrue("Fehler: Element 207 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(207)); + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852}); + + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23}); + + dieListe.anhaengen(16); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16}); + + assertTrue("Fehler: Element 173 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(173)); + assertFalse("Fehler: Element 721 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(721)); + dieListe.anhaengen(61); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16, 61}); + + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16, 61, 965}); + + assertFalse("Fehler: Element 115 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(115)); + assertFalse("Fehler: Element 666 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(666)); + assertTrue("Fehler: Element 834 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(834)); + assertFalse("Fehler: Element 636 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(636)); + dieListe.anhaengen(661); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16, 61, 965, 661}); + + assertFalse("Fehler: Element 839 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(839)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{340}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.anhaengen(210); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793}); + + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989}); + + assertFalse("Fehler: Element 654 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(654)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(930); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930}); + + dieListe.anhaengen(591); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + assertTrue("Fehler: Element 521 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(521)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45}); + + assertFalse("Fehler: Element 90 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(90)); + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877}); + + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + assertFalse("Fehler: Element 855 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(855)); + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + dieListe.anhaengen(981); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981}); + + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395}); + + assertTrue("Fehler: Element 45 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(45)); + assertFalse("Fehler: Element 312 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(312)); + assertFalse("Fehler: Element 850 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(850)); + assertFalse("Fehler: Element 659 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(659)); + assertFalse("Fehler: Element 664 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(664)); + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.anhaengen(730); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990}); + + assertTrue("Fehler: Element 591 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(591)); + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499}); + + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(300); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758}); + + assertFalse("Fehler: Element 487 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(487)); + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417}); + + dieListe.anhaengen(136); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136}); + + assertTrue("Fehler: Element 930 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(930)); + assertFalse("Fehler: Element 888 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(888)); + dieListe.anhaengen(159); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159}); + + dieListe.anhaengen(594); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626}); + + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867}); + + dieListe.anhaengen(135); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135}); + + dieListe.anhaengen(768); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768}); + + assertFalse("Fehler: Element 480 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(480)); + dieListe.anhaengen(451); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225}); + + assertFalse("Fehler: Element 185 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(185)); + assertTrue("Fehler: Element 499 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(499)); + assertTrue("Fehler: Element 417 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(417)); + assertFalse("Fehler: Element 609 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(609)); + dieListe.anhaengen(1); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1}); + + assertFalse("Fehler: Element 942 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(942)); + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576}); + + dieListe.anhaengen(54); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + assertTrue("Fehler: Element 417 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(417)); + assertFalse("Fehler: Element 100 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(100)); + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615}); + + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822}); + + dieListe.anhaengen(200); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200}); + + dieListe.anhaengen(696); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696}); + + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.anhaengen(781); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413}); + + assertFalse("Fehler: Element 175 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(175)); + assertTrue("Fehler: Element 874 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(874)); + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + assertTrue("Fehler: Element 417 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(417)); + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832}); + + assertFalse("Fehler: Element 5 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(5)); + dieListe.anhaengen(698); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698}); + + assertTrue("Fehler: Element 905 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(905)); + assertTrue("Fehler: Element 990 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(990)); + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877}); + + dieListe.anhaengen(830); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830}); + + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562, 217}); + + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); + dieListe.anhaengen(79); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562, 217, 79}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.anhaengen(678); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562, 217, 79, 678}); + + assertFalse("Fehler: Element 779 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(779)); + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{983}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675}); + + dieListe.anhaengen(165); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165}); + + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820}); + + assertFalse("Fehler: Element 314 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(314)); + assertFalse("Fehler: Element 624 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(624)); + dieListe.anhaengen(792); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312}); + + assertFalse("Fehler: Element 4 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(4)); + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783}); + + assertTrue("Fehler: Element 820 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(820)); + assertFalse("Fehler: Element 406 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(406)); + dieListe.anhaengen(916); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916}); + + assertTrue("Fehler: Element 916 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(916)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170}); + + dieListe.anhaengen(420); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484}); + + assertTrue("Fehler: Element 792 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(792)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736}); + + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 13 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(13)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881}); + + dieListe.anhaengen(728); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750}); + + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122}); + + assertTrue("Fehler: Element 728 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(728)); + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296}); + + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21}); + + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626}); + + dieListe.anhaengen(903); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903}); + + dieListe.anhaengen(641); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57}); + + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); + dieListe.anhaengen(410); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410}); + + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51}); + + dieListe.anhaengen(238); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238}); + + dieListe.anhaengen(564); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467}); + + dieListe.anhaengen(856); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856}); + + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 201 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(201)); + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723}); + + dieListe.anhaengen(978); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978}); + + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923}); + + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949}); + + assertTrue("Fehler: Element 296 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(296)); + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362}); + + assertFalse("Fehler: Element 58 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(58)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286}); + + assertTrue("Fehler: Element 750 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(750)); + assertTrue("Fehler: Element 978 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(978)); + assertFalse("Fehler: Element 207 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(207)); + dieListe.anhaengen(35); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35}); + + assertTrue("Fehler: Element 238 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(238)); + dieListe.anhaengen(941); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366}); + + assertTrue("Fehler: Element 57 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(57)); + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481}); + + assertTrue("Fehler: Element 35 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(35)); + dieListe.anhaengen(183); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575}); + + assertFalse("Fehler: Element 85 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(85)); + assertFalse("Fehler: Element 739 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(739)); + assertTrue("Fehler: Element 51 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(237); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237}); + + dieListe.anhaengen(831); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831}); + + dieListe.anhaengen(371); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371}); + + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + assertFalse("Fehler: Element 613 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(613)); + dieListe.anhaengen(143); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143}); + + assertTrue("Fehler: Element 51 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(51)); + assertTrue("Fehler: Element 983 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(983)); + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937}); + + assertFalse("Fehler: Element 929 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(929)); + assertTrue("Fehler: Element 420 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(420)); + dieListe.anhaengen(655); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655}); + + dieListe.anhaengen(492); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492}); + + dieListe.anhaengen(134); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134}); + + assertTrue("Fehler: Element 923 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(923)); + dieListe.anhaengen(309); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309, 292}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309, 292, 442}); + + assertFalse("Fehler: Element 992 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(992)); + dieListe.anhaengen(53); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309, 292, 442, 53}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(320); + Tester.pruefeListenInhalt(dieListe, new int[]{320}); + + dieListe.anhaengen(971); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971}); + + assertFalse("Fehler: Element 566 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(566)); + dieListe.anhaengen(281); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281}); + + dieListe.anhaengen(714); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714}); + + assertFalse("Fehler: Element 960 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(960)); + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334}); + + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(588); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + dieListe.anhaengen(982); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982}); + + assertFalse("Fehler: Element 868 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(868)); + assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482)); + dieListe.anhaengen(200); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211}); + + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + assertTrue("Fehler: Element 971 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(971)); + dieListe.anhaengen(537); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537}); + + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157}); + + dieListe.anhaengen(215); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215}); + + assertTrue("Fehler: Element 211 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(211)); + assertTrue("Fehler: Element 896 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(896)); + dieListe.anhaengen(540); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540}); + + dieListe.anhaengen(50); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50}); + + assertTrue("Fehler: Element 982 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(982)); + assertFalse("Fehler: Element 159 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(159)); + assertFalse("Fehler: Element 848 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(848)); + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631}); + + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + dieListe.anhaengen(823); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823}); + + dieListe.anhaengen(30); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30}); + + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414}); + + assertFalse("Fehler: Element 548 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(548)); + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633}); + + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596}); + + dieListe.anhaengen(281); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281}); + + dieListe.anhaengen(784); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964}); + + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191}); + + assertTrue("Fehler: Element 537 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(537)); + dieListe.anhaengen(530); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530}); + + assertTrue("Fehler: Element 281 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(281)); + dieListe.anhaengen(301); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301}); + + dieListe.anhaengen(384); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384}); + + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + assertFalse("Fehler: Element 574 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(574)); + assertFalse("Fehler: Element 119 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(119)); + dieListe.anhaengen(948); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948}); + + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466}); + + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774}); + + assertTrue("Fehler: Element 823 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(823)); + assertTrue("Fehler: Element 50 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(50)); + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436}); + + dieListe.anhaengen(120); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120}); + + dieListe.anhaengen(493); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493}); + + dieListe.anhaengen(377); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507}); + + assertTrue("Fehler: Element 120 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(120)); + dieListe.anhaengen(744); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744}); + + assertTrue("Fehler: Element 215 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(215)); + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.anhaengen(702); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329}); + + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + assertTrue("Fehler: Element 120 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(120)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328}); + + dieListe.anhaengen(175); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175}); + + dieListe.anhaengen(690); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690}); + + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596}); + + assertFalse("Fehler: Element 799 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(799)); + assertTrue("Fehler: Element 537 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(537)); + dieListe.anhaengen(682); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682}); + + assertFalse("Fehler: Element 683 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(683)); + dieListe.anhaengen(238); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238}); + + dieListe.anhaengen(851); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851}); + + assertFalse("Fehler: Element 831 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(831)); + assertFalse("Fehler: Element 307 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(307)); + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + assertFalse("Fehler: Element 127 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(127)); + assertTrue("Fehler: Element 414 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(414)); + dieListe.anhaengen(109); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109}); + + assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964)); + dieListe.anhaengen(491); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109, 491}); + + assertFalse("Fehler: Element 809 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(809)); + assertTrue("Fehler: Element 823 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(823)); + assertFalse("Fehler: Element 383 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(383)); + dieListe.anhaengen(134); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109, 491, 134}); + + dieListe.anhaengen(558); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109, 491, 134, 558}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(804); + Tester.pruefeListenInhalt(dieListe, new int[]{804}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + dieListe.anhaengen(93); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93}); + + dieListe.anhaengen(451); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451}); + + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529}); + + assertFalse("Fehler: Element 298 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(298)); + assertTrue("Fehler: Element 93 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124}); + + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257}); + + assertTrue("Fehler: Element 123 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(123)); + dieListe.anhaengen(928); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928}); + + dieListe.anhaengen(629); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629}); + + assertTrue("Fehler: Element 124 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(124)); + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + assertFalse("Fehler: Element 512 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(512)); + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + assertTrue("Fehler: Element 123 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(123)); + dieListe.anhaengen(504); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504}); + + dieListe.anhaengen(841); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + assertTrue("Fehler: Element 504 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(504)); + assertTrue("Fehler: Element 841 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(841)); + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788}); + + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + assertTrue("Fehler: Element 257 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(257)); + assertTrue("Fehler: Element 841 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(841)); + assertTrue("Fehler: Element 123 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(123)); + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589}); + + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + dieListe.anhaengen(836); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836}); + + assertFalse("Fehler: Element 904 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(904)); + dieListe.anhaengen(336); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957}); + + assertFalse("Fehler: Element 732 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(732)); + dieListe.anhaengen(350); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350}); + + assertFalse("Fehler: Element 581 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(789); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789}); + + dieListe.anhaengen(279); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279}); + + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + assertTrue("Fehler: Element 529 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(529)); + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + dieListe.anhaengen(158); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158}); + + assertTrue("Fehler: Element 279 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(279)); + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + assertFalse("Fehler: Element 136 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(136)); + assertTrue("Fehler: Element 336 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(336)); + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255}); + + dieListe.anhaengen(669); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359}); + + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392}); + + assertTrue("Fehler: Element 957 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(957)); + assertTrue("Fehler: Element 279 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(279)); + dieListe.anhaengen(569); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569}); + + dieListe.anhaengen(250); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413}); + + assertFalse("Fehler: Element 998 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(998)); + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670}); + + dieListe.anhaengen(925); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925}); + + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650}); + + assertFalse("Fehler: Element 640 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(640)); + assertFalse("Fehler: Element 690 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(690)); + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383}); + + dieListe.anhaengen(789); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789}); + + assertTrue("Fehler: Element 670 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(670)); + assertTrue("Fehler: Element 669 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(669)); + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + dieListe.anhaengen(291); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291}); + + dieListe.anhaengen(927); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927}); + + dieListe.anhaengen(844); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259}); + + assertTrue("Fehler: Element 93 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(93)); + assertTrue("Fehler: Element 877 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(877)); + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + assertFalse("Fehler: Element 508 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(508)); + assertTrue("Fehler: Element 925 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(925)); + dieListe.anhaengen(713); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713}); + + assertTrue("Fehler: Element 257 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(257)); + assertFalse("Fehler: Element 244 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(244)); + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651}); + + dieListe.anhaengen(843); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843}); + + assertTrue("Fehler: Element 145 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(145)); + assertFalse("Fehler: Element 818 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(818)); + assertTrue("Fehler: Element 158 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(158)); + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914}); + + dieListe.anhaengen(643); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914, 643}); + + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914, 643, 732}); + + dieListe.anhaengen(243); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914, 643, 732, 243}); + + assertTrue("Fehler: Element 650 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(650)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{845}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166}); + + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.anhaengen(961); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.anhaengen(772); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772}); + + dieListe.anhaengen(113); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113}); + + assertFalse("Fehler: Element 321 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(321)); + dieListe.anhaengen(5); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5}); + + dieListe.anhaengen(270); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270}); + + assertFalse("Fehler: Element 651 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(651)); + dieListe.anhaengen(91); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110}); + + assertTrue("Fehler: Element 270 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(270)); + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314}); + + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972}); + + assertTrue("Fehler: Element 972 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(972)); + dieListe.anhaengen(174); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743}); + + assertTrue("Fehler: Element 166 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(166)); + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434}); + + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69}); + + assertFalse("Fehler: Element 124 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(124)); + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419}); + + assertTrue("Fehler: Element 110 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(110)); + dieListe.anhaengen(241); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241}); + + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226}); + + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + assertFalse("Fehler: Element 288 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(288)); + dieListe.anhaengen(847); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847}); + + dieListe.anhaengen(567); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567}); + + assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269)); + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952}); + + assertFalse("Fehler: Element 513 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(513)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395}); + + assertFalse("Fehler: Element 744 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(744)); + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255}); + + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + assertTrue("Fehler: Element 226 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(226)); + dieListe.anhaengen(773); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 135 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(135)); + assertTrue("Fehler: Element 952 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(952)); + assertFalse("Fehler: Element 903 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(903)); + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + dieListe.anhaengen(139); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139}); + + assertFalse("Fehler: Element 245 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(245)); + assertFalse("Fehler: Element 858 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(858)); + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 222 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(222)); + assertTrue("Fehler: Element 419 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(419)); + assertTrue("Fehler: Element 226 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(226)); + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675}); + + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362}); + + assertFalse("Fehler: Element 331 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(331)); + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7}); + + assertTrue("Fehler: Element 91 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(91)); + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975}); + + dieListe.anhaengen(915); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915}); + + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + assertFalse("Fehler: Element 384 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(384)); + dieListe.anhaengen(947); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947}); + + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441}); + + assertFalse("Fehler: Element 65 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(65)); + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958}); + + dieListe.anhaengen(671); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671}); + + assertTrue("Fehler: Element 391 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(391)); + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989}); + + dieListe.anhaengen(849); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849}); + + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(519); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519, 219}); + + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + assertTrue("Fehler: Element 907 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(907)); + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519, 219, 622}); + + assertTrue("Fehler: Element 983 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(983)); + assertFalse("Fehler: Element 902 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(902)); + assertTrue("Fehler: Element 622 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(622)); + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519, 219, 622, 822}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{368}); + + dieListe.anhaengen(495); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(317); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317}); + + assertFalse("Fehler: Element 300 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(300)); + dieListe.anhaengen(796); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796}); + + assertFalse("Fehler: Element 126 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(126)); + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401}); + + assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20)); + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870}); + + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(632); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632}); + + dieListe.anhaengen(962); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962}); + + dieListe.anhaengen(374); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + assertFalse("Fehler: Element 550 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(550)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736}); + + dieListe.anhaengen(541); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541}); + + dieListe.anhaengen(432); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211}); + + dieListe.anhaengen(386); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + dieListe.anhaengen(12); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12}); + + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168}); + + assertFalse("Fehler: Element 959 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(959)); + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22}); + + assertFalse("Fehler: Element 899 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(899)); + assertFalse("Fehler: Element 940 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(940)); + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254}); + + dieListe.anhaengen(492); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492}); + + dieListe.anhaengen(172); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465}); + + assertFalse("Fehler: Element 611 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(611)); + assertFalse("Fehler: Element 991 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(991)); + dieListe.anhaengen(612); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612}); + + assertTrue("Fehler: Element 12 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(12)); + assertTrue("Fehler: Element 12 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(12)); + assertFalse("Fehler: Element 694 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(694)); + assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485)); + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57}); + + dieListe.anhaengen(520); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520}); + + assertFalse("Fehler: Element 890 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(890)); + assertFalse("Fehler: Element 411 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(411)); + assertTrue("Fehler: Element 92 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(92)); + dieListe.anhaengen(978); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978}); + + dieListe.anhaengen(899); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539}); + + assertFalse("Fehler: Element 260 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(260)); + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359}); + + assertFalse("Fehler: Element 731 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(731)); + dieListe.anhaengen(533); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533}); + + assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76)); + dieListe.anhaengen(942); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942}); + + assertFalse("Fehler: Element 336 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(336)); + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743}); + + assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140)); + assertFalse("Fehler: Element 346 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(346)); + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292}); + + dieListe.anhaengen(691); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691}); + + dieListe.anhaengen(384); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384}); + + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337}); + + dieListe.anhaengen(363); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363}); + + assertTrue("Fehler: Element 363 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(363)); + assertTrue("Fehler: Element 254 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(254)); + assertTrue("Fehler: Element 22 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(22)); + assertTrue("Fehler: Element 186 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(186)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391}); + + assertTrue("Fehler: Element 386 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(386)); + assertFalse("Fehler: Element 428 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(428)); + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562}); + + assertFalse("Fehler: Element 442 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(442)); + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293}); + + assertFalse("Fehler: Element 128 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(128)); + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + assertFalse("Fehler: Element 505 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(505)); + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940}); + + dieListe.anhaengen(887); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887}); + + assertTrue("Fehler: Element 612 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(612)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + assertFalse("Fehler: Element 830 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(830)); + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283}); + + dieListe.anhaengen(784); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784}); + + dieListe.anhaengen(706); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706}); + + assertTrue("Fehler: Element 292 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(292)); + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425}); + + dieListe.anhaengen(533); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533}); + + dieListe.anhaengen(378); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533, 378}); + + dieListe.anhaengen(563); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533, 378, 563}); + + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533, 378, 563, 322}); + + assertFalse("Fehler: Element 851 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(851)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest4.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest4.java new file mode 100644 index 0000000..3267721 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest4.java @@ -0,0 +1,2427 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest4. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest4 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 245); + Tester.pruefeListenInhalt(dieListe, new int[]{245}); + + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 907}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 907, 837}); + + assertFalse("Fehler: Element 897 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(897)); + dieListe.einfuegenBei(3, 307); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 907, 837, 307}); + + dieListe.einfuegenBei(1, 934); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307}); + + dieListe.anhaengen(498); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498}); + + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683}); + + dieListe.einfuegenBei(7, 882); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882}); + + assertFalse("Fehler: Element 435 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(435)); + assertFalse("Fehler: Element 483 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(483)); + dieListe.anhaengen(906); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906}); + + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906, 908}); + + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906, 908, 820}); + + dieListe.anhaengen(730); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906, 908, 820, 730}); + + dieListe.einfuegenBei(6, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730, 441}); + + dieListe.anhaengen(256); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730, 441, 256}); + + dieListe.anhaengen(848); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848}); + + dieListe.einfuegenBei(6, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43}); + + dieListe.einfuegenBei(0, 676); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166}); + + assertFalse("Fehler: Element 605 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(605)); + assertFalse("Fehler: Element 854 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(854)); + dieListe.einfuegenBei(3, 679); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166}); + + dieListe.einfuegenBei(21, 975); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166, 975}); + + assertFalse("Fehler: Element 914 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(914)); + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166, 975, 71}); + + dieListe.einfuegenBei(15, 177); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 730, 441, 256, 848, 43, 166, 975, 71}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 730, 441, 256, 848, 43, 166, 975, 71, 860}); + + dieListe.einfuegenBei(16, 545); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860}); + + dieListe.anhaengen(906); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906}); + + assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368)); + assertTrue("Fehler: Element 71 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(71)); + assertTrue("Fehler: Element 975 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(975)); + dieListe.anhaengen(488); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488}); + + dieListe.einfuegenBei(11, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488}); + + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77}); + + dieListe.einfuegenBei(6, 958); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77}); + + dieListe.anhaengen(356); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356}); + + assertFalse("Fehler: Element 49 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(49)); + dieListe.einfuegenBei(0, 14); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356}); + + dieListe.einfuegenBei(33, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 607}); + + dieListe.einfuegenBei(3, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 607}); + + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 607, 97}); + + dieListe.einfuegenBei(34, 795); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 97}); + + assertFalse("Fehler: Element 223 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(223)); + dieListe.einfuegenBei(4, 777); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 97}); + + dieListe.einfuegenBei(37, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + dieListe.einfuegenBei(27, 742); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 742, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertFalse("Fehler: Element 543 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(543)); + dieListe.einfuegenBei(28, 656); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.einfuegenBei(26, 478); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertTrue("Fehler: Element 307 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(307)); + dieListe.einfuegenBei(20, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97, 217}); + + assertTrue("Fehler: Element 256 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(256)); + assertTrue("Fehler: Element 462 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(462)); + dieListe.einfuegenBei(39, 591); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217}); + + dieListe.anhaengen(710); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710}); + + dieListe.einfuegenBei(24, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710}); + + assertFalse("Fehler: Element 146 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710, 861}); + + assertFalse("Fehler: Element 86 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 804 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(804)); + assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394)); + assertTrue("Fehler: Element 97 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(97)); + dieListe.anhaengen(165); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165}); + + assertTrue("Fehler: Element 860 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(860)); + assertFalse("Fehler: Element 470 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(470)); + dieListe.einfuegenBei(39, 501); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165}); + + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + dieListe.einfuegenBei(4, 504); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415)); + dieListe.einfuegenBei(7, 748); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + assertFalse("Fehler: Element 222 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(222)); + dieListe.einfuegenBei(5, 442); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970}); + + assertTrue("Fehler: Element 383 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(383)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589}); + + assertFalse("Fehler: Element 537 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(537)); + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + assertTrue("Fehler: Element 908 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(908)); + dieListe.einfuegenBei(21, 489); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + dieListe.einfuegenBei(38, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + assertTrue("Fehler: Element 837 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(837)); + dieListe.einfuegenBei(30, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 133, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + assertTrue("Fehler: Element 478 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(478)); + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + dieListe.einfuegenBei(59, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 133, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 990, 970, 589, 124, 853}); + + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 133, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 990, 970, 589, 124, 853, 625}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(549); + Tester.pruefeListenInhalt(dieListe, new int[]{549}); + + dieListe.einfuegenBei(1, 581); + Tester.pruefeListenInhalt(dieListe, new int[]{549, 581}); + + dieListe.einfuegenBei(1, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{549, 368, 581}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.einfuegenBei(1, 748); + Tester.pruefeListenInhalt(dieListe, new int[]{549, 748, 368, 581}); + + dieListe.einfuegenBei(0, 102); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581}); + + assertFalse("Fehler: Element 821 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(821)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189}); + + assertFalse("Fehler: Element 56 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(56)); + dieListe.anhaengen(657); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657}); + + dieListe.anhaengen(358); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358}); + + dieListe.anhaengen(706); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417}); + + dieListe.anhaengen(824); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824}); + + dieListe.anhaengen(506); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506}); + + dieListe.anhaengen(260); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 260}); + + assertTrue("Fehler: Element 549 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(549)); + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 260, 66}); + + dieListe.einfuegenBei(2, 855); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 260, 66}); + + assertFalse("Fehler: Element 723 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(723)); + dieListe.einfuegenBei(13, 8); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 8, 260, 66}); + + dieListe.einfuegenBei(15, 226); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66}); + + assertFalse("Fehler: Element 44 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(44)); + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66, 689}); + + assertTrue("Fehler: Element 358 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(358)); + dieListe.einfuegenBei(7, 2); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66, 689}); + + dieListe.einfuegenBei(1, 267); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66, 689}); + + dieListe.einfuegenBei(16, 861); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689}); + + assertTrue("Fehler: Element 824 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(824)); + dieListe.anhaengen(953); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 953}); + + dieListe.einfuegenBei(1, 677); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 953}); + + dieListe.einfuegenBei(22, 950); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 950, 953}); + + dieListe.einfuegenBei(8, 163); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 950, 953}); + + dieListe.einfuegenBei(20, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861)); + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.einfuegenBei(16, 62); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + assertFalse("Fehler: Element 171 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(171)); + dieListe.einfuegenBei(7, 637); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.einfuegenBei(7, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.einfuegenBei(19, 625); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.anhaengen(524); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524}); + + assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102)); + assertFalse("Fehler: Element 16 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(16)); + dieListe.anhaengen(113); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113}); + + dieListe.anhaengen(899); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860}); + + dieListe.einfuegenBei(6, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312}); + + dieListe.einfuegenBei(13, 949); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312}); + + dieListe.anhaengen(445); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 445}); + + dieListe.anhaengen(156); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 445, 156}); + + assertTrue("Fehler: Element 824 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(824)); + assertTrue("Fehler: Element 445 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(445)); + dieListe.einfuegenBei(38, 261); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 156}); + + assertFalse("Fehler: Element 907 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(907)); + dieListe.einfuegenBei(41, 718); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 156, 718}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + assertTrue("Fehler: Element 62 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(62)); + dieListe.einfuegenBei(40, 288); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718}); + + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992}); + + assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415)); + dieListe.anhaengen(30); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + dieListe.einfuegenBei(2, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + dieListe.einfuegenBei(29, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + assertTrue("Fehler: Element 713 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(713)); + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + dieListe.einfuegenBei(39, 850); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329}); + + dieListe.anhaengen(776); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776}); + + dieListe.einfuegenBei(7, 328); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776}); + + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907}); + + assertFalse("Fehler: Element 4 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(4)); + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689}); + + assertFalse("Fehler: Element 866 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(866)); + dieListe.anhaengen(621); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442}); + + assertTrue("Fehler: Element 62 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(62)); + dieListe.anhaengen(800); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800}); + + assertFalse("Fehler: Element 480 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(480)); + dieListe.einfuegenBei(30, 864); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800}); + + dieListe.einfuegenBei(9, 440); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800}); + + assertTrue("Fehler: Element 288 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(288)); + dieListe.anhaengen(422); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422}); + + assertFalse("Fehler: Element 854 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(854)); + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645}); + + dieListe.anhaengen(582); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582}); + + dieListe.einfuegenBei(10, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582}); + + dieListe.anhaengen(404); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404}); + + assertFalse("Fehler: Element 719 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(719)); + dieListe.einfuegenBei(31, 904); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787}); + + dieListe.anhaengen(244); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787, 244}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787, 244, 570}); + + dieListe.einfuegenBei(7, 835); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 835, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787, 244, 570}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{588}); + + dieListe.anhaengen(889); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889}); + + assertTrue("Fehler: Element 889 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(889)); + dieListe.anhaengen(884); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 884}); + + assertFalse("Fehler: Element 467 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(467)); + dieListe.anhaengen(151); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 884, 151}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 884, 151, 57}); + + dieListe.einfuegenBei(2, 960); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 884, 151, 57}); + + assertFalse("Fehler: Element 612 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(612)); + dieListe.anhaengen(385); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 884, 151, 57, 385}); + + dieListe.anhaengen(530); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 884, 151, 57, 385, 530}); + + dieListe.einfuegenBei(3, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 884, 151, 57, 385, 530}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 884, 151, 57, 385, 530, 637}); + + assertTrue("Fehler: Element 960 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(960)); + dieListe.einfuegenBei(8, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 884, 151, 57, 385, 647, 530, 637}); + + dieListe.einfuegenBei(4, 391); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 647, 530, 637}); + + dieListe.einfuegenBei(9, 196); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637}); + + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271}); + + assertFalse("Fehler: Element 435 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(435)); + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650}); + + dieListe.einfuegenBei(0, 854); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650}); + + dieListe.einfuegenBei(4, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650}); + + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + assertFalse("Fehler: Element 9 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(9)); + dieListe.anhaengen(141); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650, 141}); + + dieListe.anhaengen(613); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650, 141, 613}); + + dieListe.einfuegenBei(8, 720); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 196, 647, 530, 637, 271, 650, 141, 613}); + + dieListe.einfuegenBei(12, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 613}); + + dieListe.einfuegenBei(20, 432); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 432, 613}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 432, 613, 326}); + + assertTrue("Fehler: Element 78 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(78)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 432, 613, 326, 92}); + + dieListe.einfuegenBei(17, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92}); + + dieListe.einfuegenBei(1, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92}); + + assertTrue("Fehler: Element 185 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(185)); + dieListe.einfuegenBei(12, 425); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92}); + + assertTrue("Fehler: Element 613 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(613)); + assertTrue("Fehler: Element 196 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(196)); + dieListe.anhaengen(598); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598}); + + dieListe.einfuegenBei(13, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598}); + + dieListe.anhaengen(195); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195}); + + assertFalse("Fehler: Element 551 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(551)); + assertFalse("Fehler: Element 550 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(550)); + dieListe.anhaengen(582); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582}); + + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487}); + + dieListe.einfuegenBei(17, 773); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487}); + + assertFalse("Fehler: Element 769 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(769)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170}); + + dieListe.einfuegenBei(17, 838); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170, 883}); + + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170, 883, 296}); + + dieListe.anhaengen(621); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170, 883, 296, 621}); + + dieListe.einfuegenBei(31, 46); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621}); + + assertFalse("Fehler: Element 822 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(822)); + dieListe.einfuegenBei(8, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621}); + + assertTrue("Fehler: Element 196 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(196)); + assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20)); + dieListe.anhaengen(179); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179}); + + dieListe.einfuegenBei(8, 744); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179}); + + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293}); + + dieListe.einfuegenBei(15, 871); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293}); + + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 361}); + + dieListe.anhaengen(301); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 361, 301}); + + dieListe.einfuegenBei(44, 974); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301}); + + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301, 583}); + + dieListe.anhaengen(324); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301, 583, 324}); + + dieListe.einfuegenBei(13, 446); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301, 583, 324}); + + assertFalse("Fehler: Element 23 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(23)); + assertTrue("Fehler: Element 324 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(324)); + dieListe.einfuegenBei(47, 505); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 583, 324}); + + dieListe.einfuegenBei(19, 321); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 583, 324}); + + assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195)); + dieListe.einfuegenBei(50, 815); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324}); + + dieListe.anhaengen(649); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649}); + + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + dieListe.einfuegenBei(38, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649}); + + dieListe.einfuegenBei(31, 405); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649}); + + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + dieListe.anhaengen(692); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692}); + + dieListe.einfuegenBei(26, 558); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692}); + + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932}); + + assertFalse("Fehler: Element 229 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(229)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69}); + + assertTrue("Fehler: Element 613 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(613)); + assertFalse("Fehler: Element 615 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(615)); + dieListe.einfuegenBei(11, 480); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69}); + + assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313)); + dieListe.anhaengen(667); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69, 667}); + + dieListe.anhaengen(393); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393}); + + dieListe.anhaengen(830); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393, 830}); + + dieListe.einfuegenBei(54, 978); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393, 830}); + + dieListe.einfuegenBei(26, 901); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 901, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393, 830}); + + dieListe.einfuegenBei(64, 207); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 901, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 207, 667, 393, 830}); + + assertFalse("Fehler: Element 851 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(851)); + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + assertFalse("Fehler: Element 653 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(653)); + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 901, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 207, 667, 393, 830, 51}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{390}); + + dieListe.einfuegenBei(1, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75}); + + dieListe.einfuegenBei(2, 282); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75, 282}); + + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75, 282, 653}); + + assertFalse("Fehler: Element 195 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(195)); + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75, 282, 653, 596}); + + dieListe.einfuegenBei(1, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 398, 75, 282, 653, 596}); + + assertFalse("Fehler: Element 636 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(636)); + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.einfuegenBei(0, 461); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 282, 653, 596}); + + dieListe.einfuegenBei(4, 586); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.anhaengen(144); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596, 144}); + + dieListe.anhaengen(104); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596, 144, 104}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596, 144, 104, 619}); + + assertFalse("Fehler: Element 834 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(834)); + dieListe.einfuegenBei(4, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299}); + + assertTrue("Fehler: Element 461 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(461)); + dieListe.anhaengen(617); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617}); + + dieListe.anhaengen(233); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233}); + + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233, 92}); + + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233, 92, 306}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233, 92, 306, 225}); + + dieListe.einfuegenBei(11, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225}); + + dieListe.anhaengen(678); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678}); + + assertFalse("Fehler: Element 332 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(332)); + dieListe.einfuegenBei(5, 129); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312}); + + dieListe.anhaengen(202); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202}); + + assertFalse("Fehler: Element 500 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(500)); + assertFalse("Fehler: Element 264 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(264)); + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + dieListe.einfuegenBei(7, 312); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 312, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + dieListe.einfuegenBei(3, 299); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + assertTrue("Fehler: Element 596 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(596)); + dieListe.einfuegenBei(11, 335); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353}); + + dieListe.anhaengen(94); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94}); + + assertFalse("Fehler: Element 928 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(928)); + assertFalse("Fehler: Element 799 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(799)); + assertFalse("Fehler: Element 976 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(913); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913}); + + assertFalse("Fehler: Element 473 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(473)); + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264}); + + dieListe.anhaengen(468); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 468}); + + dieListe.einfuegenBei(17, 868); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 468}); + + dieListe.einfuegenBei(20, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 468}); + + dieListe.einfuegenBei(33, 781); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 781, 468}); + + dieListe.einfuegenBei(35, 786); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 781, 468, 786}); + + dieListe.einfuegenBei(33, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786}); + + dieListe.einfuegenBei(6, 25); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786}); + + dieListe.anhaengen(451); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + dieListe.einfuegenBei(20, 337); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + dieListe.einfuegenBei(12, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + assertTrue("Fehler: Element 335 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(335)); + dieListe.einfuegenBei(31, 389); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.anhaengen(287); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110}); + + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989}); + + dieListe.anhaengen(850); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850}); + + dieListe.anhaengen(227); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227}); + + assertFalse("Fehler: Element 539 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(539)); + assertFalse("Fehler: Element 773 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(773)); + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertFalse("Fehler: Element 500 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(500)); + dieListe.anhaengen(106); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106}); + + dieListe.einfuegenBei(8, 894); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106}); + + assertFalse("Fehler: Element 541 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(541)); + dieListe.einfuegenBei(1, 792); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106}); + + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535}); + + dieListe.anhaengen(987); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987}); + + assertTrue("Fehler: Element 92 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(92)); + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.einfuegenBei(26, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543}); + + dieListe.einfuegenBei(22, 786); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.anhaengen(400); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543, 400}); + + assertFalse("Fehler: Element 582 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(582)); + dieListe.einfuegenBei(49, 463); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400}); + + assertTrue("Fehler: Element 25 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(25)); + assertFalse("Fehler: Element 964 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(964)); + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89}); + + dieListe.anhaengen(190); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(18, 317); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(29, 519); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(53, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(23, 115); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + dieListe.einfuegenBei(41, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 991, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(49, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 991, 94, 913, 264, 481, 781, 468, 786, 555, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(7, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 546, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 991, 94, 913, 264, 481, 781, 468, 786, 555, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + assertFalse("Fehler: Element 691 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(691)); + assertFalse("Fehler: Element 791 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(791)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 805); + Tester.pruefeListenInhalt(dieListe, new int[]{805}); + + dieListe.anhaengen(610); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 610}); + + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 610, 467}); + + dieListe.einfuegenBei(1, 890); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467}); + + dieListe.anhaengen(552); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935}); + + dieListe.anhaengen(46); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935, 46}); + + dieListe.einfuegenBei(7, 460); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935, 46, 460}); + + dieListe.anhaengen(994); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935, 46, 460, 994}); + + assertTrue("Fehler: Element 552 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(552)); + assertTrue("Fehler: Element 552 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(552)); + dieListe.einfuegenBei(3, 787); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 787, 467, 552, 935, 46, 460, 994}); + + assertFalse("Fehler: Element 385 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(385)); + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 787, 467, 552, 935, 46, 460, 994, 646}); + + assertFalse("Fehler: Element 934 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(934)); + dieListe.einfuegenBei(3, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 994, 646}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 994, 646, 297}); + + dieListe.einfuegenBei(11, 99); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 994, 99, 646, 297}); + + assertTrue("Fehler: Element 805 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(805)); + assertFalse("Fehler: Element 565 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(565)); + dieListe.einfuegenBei(10, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 144, 994, 99, 646, 297}); + + assertFalse("Fehler: Element 247 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(247)); + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 144, 994, 99, 646, 297, 417}); + + dieListe.einfuegenBei(14, 433); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 144, 994, 99, 646, 433, 297, 417}); + + assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890)); + dieListe.einfuegenBei(10, 693); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 693, 144, 994, 99, 646, 433, 297, 417}); + + dieListe.einfuegenBei(14, 680); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 693, 144, 994, 99, 680, 646, 433, 297, 417}); + + dieListe.einfuegenBei(10, 114); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 99, 680, 646, 433, 297, 417}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 99, 680, 646, 433, 297, 417, 469}); + + dieListe.einfuegenBei(14, 310); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 680, 646, 433, 297, 417, 469}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 680, 646, 433, 297, 417, 469, 351}); + + dieListe.einfuegenBei(16, 791); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 680, 646, 433, 297, 417, 469, 351}); + + dieListe.anhaengen(982); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 680, 646, 433, 297, 417, 469, 351, 982}); + + dieListe.anhaengen(404); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 680, 646, 433, 297, 417, 469, 351, 982, 404}); + + dieListe.einfuegenBei(17, 184); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404}); + + dieListe.anhaengen(765); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.einfuegenBei(5, 285); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.einfuegenBei(10, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.einfuegenBei(13, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743}); + + assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816}); + + assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269)); + assertFalse("Fehler: Element 833 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(833)); + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908}); + + assertTrue("Fehler: Element 765 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(765)); + dieListe.einfuegenBei(6, 66); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908}); + + dieListe.einfuegenBei(10, 519); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908}); + + dieListe.anhaengen(513); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513}); + + dieListe.anhaengen(427); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427}); + + assertFalse("Fehler: Element 528 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(528)); + dieListe.anhaengen(961); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315}); + + dieListe.anhaengen(68); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68}); + + assertTrue("Fehler: Element 184 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(184)); + assertTrue("Fehler: Element 310 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(310)); + assertFalse("Fehler: Element 418 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(418)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170}); + + dieListe.einfuegenBei(19, 635); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170}); + + dieListe.einfuegenBei(6, 385); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170}); + + assertTrue("Fehler: Element 310 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(310)); + dieListe.anhaengen(304); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304}); + + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89}); + + dieListe.anhaengen(475); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475}); + + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328}); + + assertTrue("Fehler: Element 89 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(89)); + assertTrue("Fehler: Element 328 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(328)); + dieListe.anhaengen(943); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943}); + + dieListe.einfuegenBei(38, 338); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943}); + + assertFalse("Fehler: Element 534 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(534)); + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763}); + + dieListe.einfuegenBei(11, 506); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763}); + + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463}); + + dieListe.anhaengen(416); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416}); + + dieListe.einfuegenBei(12, 88); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416}); + + dieListe.einfuegenBei(8, 469); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416}); + + assertFalse("Fehler: Element 493 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(493)); + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + dieListe.einfuegenBei(34, 410); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487}); + + assertTrue("Fehler: Element 805 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(805)); + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487, 867}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + dieListe.einfuegenBei(36, 286); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + assertFalse("Fehler: Element 618 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(618)); + assertFalse("Fehler: Element 383 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(383)); + dieListe.einfuegenBei(53, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + dieListe.einfuegenBei(36, 800); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + assertTrue("Fehler: Element 404 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(404)); + dieListe.einfuegenBei(35, 232); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + dieListe.einfuegenBei(10, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + assertTrue("Fehler: Element 610 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(610)); + dieListe.einfuegenBei(10, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 686, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + dieListe.einfuegenBei(58, 867); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 686, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 867, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + assertTrue("Fehler: Element 88 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(88)); + dieListe.einfuegenBei(61, 230); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 686, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 867, 475, 328, 230, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + assertTrue("Fehler: Element 994 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(994)); + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 903); + Tester.pruefeListenInhalt(dieListe, new int[]{903}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723, 593}); + + dieListe.anhaengen(546); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723, 593, 546}); + + dieListe.anhaengen(300); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723, 593, 546, 300}); + + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + dieListe.einfuegenBei(1, 529); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 593, 546, 300}); + + dieListe.einfuegenBei(3, 914); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 546, 300}); + + assertFalse("Fehler: Element 873 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(873)); + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 546, 300, 334}); + + dieListe.einfuegenBei(5, 696); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 696, 546, 300, 334}); + + dieListe.anhaengen(443); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 696, 546, 300, 334, 443}); + + dieListe.einfuegenBei(6, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 696, 92, 546, 300, 334, 443}); + + dieListe.einfuegenBei(3, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 688, 914, 593, 696, 92, 546, 300, 334, 443}); + + dieListe.anhaengen(514); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 688, 914, 593, 696, 92, 546, 300, 334, 443, 514}); + + assertFalse("Fehler: Element 882 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(882)); + assertTrue("Fehler: Element 514 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(514)); + dieListe.einfuegenBei(2, 17); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 696, 92, 546, 300, 334, 443, 514}); + + dieListe.einfuegenBei(7, 326); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47}); + + dieListe.anhaengen(752); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752}); + + dieListe.anhaengen(836); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752, 836}); + + assertFalse("Fehler: Element 730 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(730)); + assertTrue("Fehler: Element 443 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(443)); + assertTrue("Fehler: Element 514 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(514)); + assertTrue("Fehler: Element 443 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(443)); + assertTrue("Fehler: Element 723 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(723)); + dieListe.einfuegenBei(2, 217); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752, 836}); + + dieListe.anhaengen(624); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752, 836, 624}); + + dieListe.einfuegenBei(15, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463}); + + dieListe.anhaengen(559); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559}); + + assertTrue("Fehler: Element 463 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(463)); + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322}); + + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322, 890}); + + assertFalse("Fehler: Element 14 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(14)); + assertTrue("Fehler: Element 17 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(17)); + dieListe.einfuegenBei(2, 342); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322, 890}); + + dieListe.anhaengen(228); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228}); + + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.einfuegenBei(17, 433); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228}); + + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731}); + + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + assertTrue("Fehler: Element 752 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(752)); + dieListe.einfuegenBei(19, 358); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + assertFalse("Fehler: Element 754 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(754)); + dieListe.einfuegenBei(5, 541); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + dieListe.einfuegenBei(18, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583, 382}); + + assertFalse("Fehler: Element 974 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(974)); + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583, 382, 783}); + + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583, 382, 783, 335}); + + dieListe.einfuegenBei(31, 12); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 12, 731, 583, 382, 783, 335}); + + dieListe.einfuegenBei(18, 752); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 12, 731, 583, 382, 783, 335}); + + assertFalse("Fehler: Element 892 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(892)); + dieListe.anhaengen(572); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 12, 731, 583, 382, 783, 335, 572}); + + assertFalse("Fehler: Element 600 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(600)); + dieListe.einfuegenBei(31, 301); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 731, 583, 382, 783, 335, 572}); + + dieListe.einfuegenBei(18, 343); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 731, 583, 382, 783, 335, 572}); + + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 731, 583, 382, 783, 335, 572, 622}); + + dieListe.einfuegenBei(35, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622}); + + assertTrue("Fehler: Element 343 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(343)); + dieListe.einfuegenBei(16, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622}); + + assertTrue("Fehler: Element 731 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(731)); + dieListe.anhaengen(17); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17}); + + assertFalse("Fehler: Element 508 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(508)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + assertFalse("Fehler: Element 86 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 175 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(175)); + dieListe.anhaengen(817); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.einfuegenBei(8, 767); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.einfuegenBei(25, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.einfuegenBei(38, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817, 557}); + + assertTrue("Fehler: Element 572 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(572)); + assertTrue("Fehler: Element 767 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(767)); + assertTrue("Fehler: Element 433 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(433)); + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817, 557, 534}); + + assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501)); + dieListe.einfuegenBei(45, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 534}); + + dieListe.einfuegenBei(52, 868); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534}); + + dieListe.anhaengen(567); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567}); + + dieListe.einfuegenBei(38, 263); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567}); + + dieListe.einfuegenBei(35, 376); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567}); + + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567, 659}); + + dieListe.einfuegenBei(55, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659}); + + dieListe.einfuegenBei(39, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659}); + + dieListe.einfuegenBei(48, 542); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659}); + + dieListe.anhaengen(125); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125}); + + dieListe.einfuegenBei(17, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125, 727}); + + dieListe.einfuegenBei(52, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 208, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125, 727}); + + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + assertFalse("Fehler: Element 27 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(27)); + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 208, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125, 727, 605}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{627}); + + dieListe.einfuegenBei(0, 602); + Tester.pruefeListenInhalt(dieListe, new int[]{602, 627}); + + dieListe.einfuegenBei(0, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 602, 627}); + + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 602, 627, 623}); + + dieListe.einfuegenBei(0, 793); + Tester.pruefeListenInhalt(dieListe, new int[]{793, 208, 602, 627, 623}); + + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + dieListe.einfuegenBei(1, 378); + Tester.pruefeListenInhalt(dieListe, new int[]{793, 378, 208, 602, 627, 623}); + + dieListe.einfuegenBei(0, 687); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 602, 627, 623}); + + dieListe.einfuegenBei(4, 993); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623}); + + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 699}); + + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 699, 725}); + + dieListe.einfuegenBei(10, 527); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 699, 725, 527}); + + dieListe.einfuegenBei(8, 429); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 527}); + + assertFalse("Fehler: Element 280 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(280)); + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 527, 861}); + + dieListe.anhaengen(782); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 527, 861, 782}); + + dieListe.einfuegenBei(11, 516); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 527, 861, 782}); + + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 527, 861, 782, 401}); + + assertFalse("Fehler: Element 79 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(79)); + dieListe.einfuegenBei(12, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 42, 527, 861, 782, 401}); + + assertFalse("Fehler: Element 410 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(410)); + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 42, 527, 861, 782, 401, 595}); + + dieListe.einfuegenBei(10, 733); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595}); + + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595, 832}); + + dieListe.einfuegenBei(20, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413}); + + assertTrue("Fehler: Element 782 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(782)); + assertFalse("Fehler: Element 423 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(423)); + assertFalse("Fehler: Element 920 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(356); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356}); + + dieListe.einfuegenBei(11, 938); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356}); + + dieListe.einfuegenBei(10, 744); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356, 700}); + + dieListe.einfuegenBei(23, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 766, 356, 700}); + + dieListe.einfuegenBei(16, 855); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 855, 527, 861, 782, 401, 595, 832, 413, 766, 356, 700}); + + dieListe.einfuegenBei(9, 978); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 527, 861, 782, 401, 595, 832, 413, 766, 356, 700}); + + assertTrue("Fehler: Element 938 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(938)); + dieListe.einfuegenBei(26, 508); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700}); + + assertFalse("Fehler: Element 775 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(775)); + assertTrue("Fehler: Element 700 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(700)); + dieListe.einfuegenBei(18, 619); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576}); + + dieListe.anhaengen(561); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561}); + + dieListe.anhaengen(132); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132}); + + assertTrue("Fehler: Element 855 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(855)); + assertTrue("Fehler: Element 208 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(208)); + assertTrue("Fehler: Element 855 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(855)); + assertFalse("Fehler: Element 986 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(986)); + assertFalse("Fehler: Element 945 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(945)); + dieListe.einfuegenBei(5, 469); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110}); + + dieListe.einfuegenBei(0, 954); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110}); + + dieListe.anhaengen(546); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + dieListe.einfuegenBei(14, 327); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358)); + dieListe.einfuegenBei(4, 378); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + dieListe.einfuegenBei(30, 620); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + assertFalse("Fehler: Element 495 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(495)); + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277}); + + assertFalse("Fehler: Element 43 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(43)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277, 589}); + + dieListe.einfuegenBei(11, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277, 589}); + + dieListe.einfuegenBei(44, 290); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277, 589, 290}); + + dieListe.einfuegenBei(41, 819); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290}); + + assertFalse("Fehler: Element 421 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(421)); + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + dieListe.anhaengen(460); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 460}); + + assertTrue("Fehler: Element 602 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(602)); + assertTrue("Fehler: Element 516 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(516)); + assertTrue("Fehler: Element 687 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(687)); + assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297)); + dieListe.einfuegenBei(29, 65); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 460}); + + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 460, 783}); + + assertFalse("Fehler: Element 705 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(705)); + dieListe.einfuegenBei(47, 399); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783}); + + dieListe.anhaengen(977); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783, 977}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783, 977, 442}); + + dieListe.einfuegenBei(11, 27); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783, 977, 442}); + + dieListe.einfuegenBei(49, 32); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442}); + + dieListe.anhaengen(244); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442, 244}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442, 244, 909}); + + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442, 244, 909, 180}); + + dieListe.einfuegenBei(51, 121); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180}); + + dieListe.einfuegenBei(21, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180}); + + dieListe.anhaengen(698); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698}); + + dieListe.einfuegenBei(5, 440); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698}); + + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777}); + + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82}); + + dieListe.einfuegenBei(43, 764); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82}); + + dieListe.anhaengen(321); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321}); + + dieListe.anhaengen(545); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545}); + + dieListe.anhaengen(549); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549}); + + dieListe.einfuegenBei(50, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549}); + + assertTrue("Fehler: Element 954 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(954)); + dieListe.einfuegenBei(52, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 572, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 572, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549, 264}); + + dieListe.einfuegenBei(3, 337); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 337, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 572, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549, 264}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 9); + Tester.pruefeListenInhalt(dieListe, new int[]{9}); + + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 388}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 388, 990}); + + dieListe.einfuegenBei(0, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 9, 388, 990}); + + assertFalse("Fehler: Element 474 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(474)); + dieListe.einfuegenBei(0, 621); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990}); + + dieListe.einfuegenBei(5, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741}); + + assertFalse("Fehler: Element 30 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(30)); + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122}); + + dieListe.anhaengen(831); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831}); + + dieListe.einfuegenBei(8, 197); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831, 197}); + + assertTrue("Fehler: Element 990 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(990)); + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831, 197, 257}); + + assertTrue("Fehler: Element 122 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(122)); + assertTrue("Fehler: Element 122 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(122)); + dieListe.anhaengen(882); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831, 197, 257, 882}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.einfuegenBei(4, 618); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 741, 122, 831, 197, 257, 882}); + + assertTrue("Fehler: Element 882 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(882)); + dieListe.einfuegenBei(10, 964); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 741, 122, 831, 197, 964, 257, 882}); + + dieListe.einfuegenBei(6, 188); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 188, 741, 122, 831, 197, 964, 257, 882}); + + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 188, 741, 122, 831, 197, 964, 257, 882, 357}); + + assertFalse("Fehler: Element 667 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(667)); + dieListe.einfuegenBei(6, 566); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 741, 122, 831, 197, 964, 257, 882, 357}); + + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 741, 122, 831, 197, 964, 257, 882, 357, 207}); + + assertFalse("Fehler: Element 824 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(824)); + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.einfuegenBei(8, 591); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786}); + + dieListe.anhaengen(390); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 413}); + + dieListe.einfuegenBei(20, 864); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297}); + + assertFalse("Fehler: Element 858 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(858)); + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368}); + + assertTrue("Fehler: Element 990 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(990)); + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439}); + + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921}); + + assertFalse("Fehler: Element 982 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(982)); + assertTrue("Fehler: Element 188 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(188)); + dieListe.einfuegenBei(7, 484); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 484, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921}); + + dieListe.einfuegenBei(7, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921}); + + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937}); + + dieListe.einfuegenBei(12, 291); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937}); + + dieListe.anhaengen(829); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937, 829}); + + assertFalse("Fehler: Element 600 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(600)); + assertFalse("Fehler: Element 453 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(453)); + assertTrue("Fehler: Element 937 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(937)); + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + assertFalse("Fehler: Element 988 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(988)); + dieListe.einfuegenBei(23, 905); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(8, 66); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 66, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(9, 196); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(2, 655); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(28, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.anhaengen(855); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855}); + + assertFalse("Fehler: Element 164 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(164)); + dieListe.anhaengen(813); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813}); + + assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707)); + dieListe.einfuegenBei(7, 815); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.einfuegenBei(8, 391); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813}); + + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(901); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901}); + + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + dieListe.einfuegenBei(29, 383); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.einfuegenBei(26, 43); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901}); + + assertFalse("Fehler: Element 504 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(504)); + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543}); + + assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156)); + assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395}); + + dieListe.einfuegenBei(10, 800); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437}); + + assertFalse("Fehler: Element 293 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(293)); + dieListe.einfuegenBei(2, 437); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437}); + + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894}); + + dieListe.anhaengen(298); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298}); + + dieListe.einfuegenBei(28, 52); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298}); + + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625}); + + dieListe.anhaengen(548); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883}); + + dieListe.einfuegenBei(21, 714); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883}); + + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894}); + + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660}); + + dieListe.einfuegenBei(0, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660}); + + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + assertTrue("Fehler: Element 122 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(122)); + dieListe.anhaengen(184); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184}); + + assertTrue("Fehler: Element 188 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(188)); + dieListe.einfuegenBei(37, 411); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184}); + + assertTrue("Fehler: Element 894 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(894)); + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154}); + + assertTrue("Fehler: Element 864 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(864)); + dieListe.einfuegenBei(45, 381); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 381, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154}); + + dieListe.anhaengen(269); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 381, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154, 269}); + + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 381, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154, 269, 769}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{866}); + + assertTrue("Fehler: Element 866 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(866)); + dieListe.einfuegenBei(1, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 555}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); + dieListe.einfuegenBei(1, 303); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 555}); + + assertFalse("Fehler: Element 834 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(834)); + dieListe.einfuegenBei(2, 804); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555}); + + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711}); + + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + dieListe.anhaengen(995); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 995}); + + dieListe.einfuegenBei(5, 295); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995}); + + assertFalse("Fehler: Element 376 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(376)); + dieListe.anhaengen(585); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585}); + + dieListe.anhaengen(113); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113}); + + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 683}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 683, 704}); + + assertTrue("Fehler: Element 585 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(585)); + dieListe.anhaengen(80); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 683, 704, 80}); + + dieListe.einfuegenBei(9, 853); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 853, 683, 704, 80}); + + dieListe.anhaengen(162); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 853, 683, 704, 80, 162}); + + assertTrue("Fehler: Element 295 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(295)); + dieListe.einfuegenBei(11, 407); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162}); + + dieListe.einfuegenBei(4, 166); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450}); + + assertTrue("Fehler: Element 995 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(995)); + assertFalse("Fehler: Element 240 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(240)); + dieListe.anhaengen(859); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859}); + + dieListe.anhaengen(233); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233}); + + dieListe.einfuegenBei(1, 775); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233}); + + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283}); + + dieListe.anhaengen(746); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746}); + + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746, 481}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746, 481, 974}); + + assertFalse("Fehler: Element 933 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(933)); + dieListe.anhaengen(64); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746, 481, 974, 64}); + + dieListe.einfuegenBei(19, 721); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64}); + + dieListe.anhaengen(171); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64, 171}); + + dieListe.einfuegenBei(1, 417); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64, 171}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64, 171, 51}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + assertFalse("Fehler: Element 997 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(997)); + dieListe.einfuegenBei(22, 928); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51}); + + dieListe.anhaengen(533); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533}); + + assertFalse("Fehler: Element 744 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(744)); + dieListe.einfuegenBei(31, 423); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423}); + + assertFalse("Fehler: Element 874 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(874)); + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461}); + + dieListe.einfuegenBei(14, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461}); + + dieListe.einfuegenBei(0, 907); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461}); + + assertTrue("Fehler: Element 704 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(704)); + dieListe.anhaengen(872); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225}); + + dieListe.einfuegenBei(16, 306); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225}); + + assertTrue("Fehler: Element 721 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(721)); + assertTrue("Fehler: Element 859 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(859)); + dieListe.einfuegenBei(6, 837); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225, 861}); + + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225, 861, 608}); + + dieListe.einfuegenBei(36, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 608}); + + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 608, 127}); + + dieListe.einfuegenBei(41, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127}); + + dieListe.einfuegenBei(28, 399); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127}); + + dieListe.einfuegenBei(6, 889); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127}); + + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712}); + + assertTrue("Fehler: Element 866 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(866)); + dieListe.einfuegenBei(29, 314); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712}); + + dieListe.einfuegenBei(7, 253); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712}); + + assertFalse("Fehler: Element 935 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(935)); + assertFalse("Fehler: Element 221 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(221)); + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.einfuegenBei(6, 680); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.einfuegenBei(39, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.einfuegenBei(12, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589}); + + dieListe.anhaengen(509); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + dieListe.einfuegenBei(1, 929); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + assertTrue("Fehler: Element 775 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(775)); + dieListe.einfuegenBei(21, 336); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + assertTrue("Fehler: Element 303 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(303)); + dieListe.einfuegenBei(9, 951); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + dieListe.einfuegenBei(58, 628); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628}); + + dieListe.anhaengen(713); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.anhaengen(223); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223}); + + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(1, 439); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(6, 693); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(52, 219); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(51, 444); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(52, 908); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263}); + + assertFalse("Fehler: Element 665 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(665)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226}); + + dieListe.anhaengen(48); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48}); + + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251}); + + dieListe.einfuegenBei(0, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{462, 907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251}); + + dieListe.anhaengen(350); + Tester.pruefeListenInhalt(dieListe, new int[]{462, 907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251, 350}); + + dieListe.einfuegenBei(1, 773); + Tester.pruefeListenInhalt(dieListe, new int[]{462, 773, 907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251, 350}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 619); + Tester.pruefeListenInhalt(dieListe, new int[]{619}); + + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{619, 168}); + + assertTrue("Fehler: Element 168 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(168)); + dieListe.einfuegenBei(2, 199); + Tester.pruefeListenInhalt(dieListe, new int[]{619, 168, 199}); + + assertTrue("Fehler: Element 168 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(168)); + dieListe.anhaengen(202); + Tester.pruefeListenInhalt(dieListe, new int[]{619, 168, 199, 202}); + + dieListe.einfuegenBei(0, 326); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202}); + + dieListe.einfuegenBei(5, 747); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747, 194}); + + assertTrue("Fehler: Element 202 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(202)); + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + assertFalse("Fehler: Element 228 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(228)); + assertTrue("Fehler: Element 326 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(326)); + assertFalse("Fehler: Element 431 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(431)); + assertTrue("Fehler: Element 326 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(326)); + dieListe.anhaengen(243); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747, 194, 243}); + + dieListe.anhaengen(798); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747, 194, 243, 798}); + + dieListe.einfuegenBei(0, 76); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 747, 194, 243, 798}); + + dieListe.anhaengen(67); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 747, 194, 243, 798, 67}); + + dieListe.einfuegenBei(6, 455); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 455, 747, 194, 243, 798, 67}); + + dieListe.anhaengen(895); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 455, 747, 194, 243, 798, 67, 895}); + + assertFalse("Fehler: Element 524 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(524)); + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + assertFalse("Fehler: Element 450 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(450)); + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + dieListe.anhaengen(289); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 455, 747, 194, 243, 798, 67, 895, 289}); + + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + assertTrue("Fehler: Element 798 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(798)); + dieListe.einfuegenBei(6, 160); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289, 852}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289, 852, 644}); + + dieListe.einfuegenBei(1, 807); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289, 852, 644}); + + assertFalse("Fehler: Element 856 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(856)); + dieListe.einfuegenBei(13, 808); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644}); + + assertFalse("Fehler: Element 233 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(233)); + dieListe.einfuegenBei(8, 284); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644}); + + dieListe.einfuegenBei(7, 96); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644}); + + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 482}); + + dieListe.anhaengen(892); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 482, 892}); + + dieListe.einfuegenBei(21, 287); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892}); + + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383}); + + dieListe.einfuegenBei(14, 501); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383}); + + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627}); + + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251, 442}); + + dieListe.anhaengen(803); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251, 442, 803}); + + assertFalse("Fehler: Element 696 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(696)); + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251, 442, 803, 820}); + + dieListe.einfuegenBei(22, 541); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 892, 383, 627, 251, 442, 803, 820}); + + dieListe.anhaengen(188); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 892, 383, 627, 251, 442, 803, 820, 188}); + + dieListe.einfuegenBei(25, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188}); + + dieListe.einfuegenBei(12, 242); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188}); + + assertFalse("Fehler: Element 987 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 202 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(202)); + assertFalse("Fehler: Element 731 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(731)); + assertFalse("Fehler: Element 57 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(57)); + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89}); + + dieListe.einfuegenBei(2, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89}); + + assertFalse("Fehler: Element 788 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(788)); + dieListe.einfuegenBei(11, 667); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89}); + + dieListe.anhaengen(755); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755}); + + assertFalse("Fehler: Element 812 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(812)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + dieListe.einfuegenBei(25, 824); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755}); + + dieListe.einfuegenBei(2, 550); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755}); + + dieListe.anhaengen(524); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524}); + + assertTrue("Fehler: Element 242 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(242)); + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219}); + + assertFalse("Fehler: Element 8 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(8)); + dieListe.einfuegenBei(2, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219}); + + dieListe.anhaengen(298); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211}); + + dieListe.einfuegenBei(8, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211}); + + dieListe.anhaengen(587); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211, 587}); + + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211, 587, 615}); + + dieListe.einfuegenBei(41, 642); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615}); + + dieListe.anhaengen(996); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996}); + + assertTrue("Fehler: Element 67 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(67)); + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996, 39}); + + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996, 39, 7}); + + assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892)); + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(44, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(9, 544); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 544, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(36, 461); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 544, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(1, 997); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + assertFalse("Fehler: Element 310 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(310)); + dieListe.einfuegenBei(11, 437); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708}); + + assertFalse("Fehler: Element 428 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(428)); + dieListe.einfuegenBei(28, 548); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708}); + + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467}); + + dieListe.einfuegenBei(48, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467}); + + assertFalse("Fehler: Element 628 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(628)); + dieListe.einfuegenBei(12, 645); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467}); + + assertFalse("Fehler: Element 247 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(247)); + dieListe.anhaengen(654); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467, 654}); + + dieListe.einfuegenBei(43, 309); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 309, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467, 654}); + + dieListe.anhaengen(240); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 309, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467, 654, 240}); + + assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest5.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest5.java new file mode 100644 index 0000000..f2be0d0 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest5.java @@ -0,0 +1,2397 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest5. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest5 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{86}); + + assertTrue("Fehler: Element 86 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(86)); + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 145}); + + assertTrue("Fehler: Element 86 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 169 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(169)); + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 145, 788}); + + assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.einfuegenBei(1, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 991, 145, 788}); + + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.einfuegenBei(4, 931); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 991, 145, 788, 931}); + + assertFalse("Fehler: Element 611 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(611)); + dieListe.einfuegenBei(0, 201); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 991, 145, 788, 931}); + + dieListe.einfuegenBei(2, 153); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931}); + + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 69}); + + dieListe.einfuegenBei(7, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 297}); + + dieListe.einfuegenBei(9, 147); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 147, 297}); + + dieListe.anhaengen(963); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 147, 297, 963}); + + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334}); + + dieListe.einfuegenBei(3, 972); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334}); + + dieListe.anhaengen(842); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334, 842}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334, 842, 267}); + + assertFalse("Fehler: Element 682 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(682)); + dieListe.einfuegenBei(12, 275); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758, 341}); + + dieListe.anhaengen(233); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758, 341, 233}); + + dieListe.anhaengen(819); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758, 341, 233, 819}); + + dieListe.einfuegenBei(14, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 853}); + + assertTrue("Fehler: Element 334 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(334)); + assertFalse("Fehler: Element 401 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(401)); + dieListe.einfuegenBei(8, 859); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 853}); + + assertFalse("Fehler: Element 623 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(623)); + assertTrue("Fehler: Element 275 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(275)); + assertFalse("Fehler: Element 645 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(645)); + dieListe.anhaengen(804); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 853, 804}); + + assertTrue("Fehler: Element 233 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(233)); + dieListe.einfuegenBei(23, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 59, 853, 804}); + + dieListe.einfuegenBei(23, 285); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 285, 59, 853, 804}); + + dieListe.einfuegenBei(18, 283); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675}); + + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547}); + + assertFalse("Fehler: Element 589 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(589)); + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972}); + + assertFalse("Fehler: Element 453 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(453)); + dieListe.anhaengen(991); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 991}); + + dieListe.einfuegenBei(13, 197); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 991}); + + dieListe.einfuegenBei(33, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 360, 991}); + + assertFalse("Fehler: Element 744 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(744)); + dieListe.anhaengen(177); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 360, 991, 177}); + + assertFalse("Fehler: Element 497 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(497)); + dieListe.einfuegenBei(1, 31); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 360, 991, 177}); + + dieListe.einfuegenBei(34, 934); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177}); + + dieListe.anhaengen(770); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770}); + + dieListe.anhaengen(339); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339}); + + dieListe.anhaengen(513); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339, 513}); + + assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486)); + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339, 513, 937}); + + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339, 513, 937, 348}); + + dieListe.einfuegenBei(34, 254); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348}); + + assertFalse("Fehler: Element 402 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(402)); + dieListe.einfuegenBei(14, 211); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 211, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 211, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.einfuegenBei(9, 951); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.einfuegenBei(19, 655); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + assertFalse("Fehler: Element 557 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(557)); + dieListe.einfuegenBei(24, 522); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.einfuegenBei(7, 738); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302, 972}); + + dieListe.einfuegenBei(3, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302, 972}); + + dieListe.einfuegenBei(50, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972}); + + dieListe.anhaengen(834); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834}); + + dieListe.anhaengen(269); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269}); + + assertFalse("Fehler: Element 784 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(784)); + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894}); + + assertFalse("Fehler: Element 442 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(442)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226}); + + assertFalse("Fehler: Element 883 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(883)); + dieListe.anhaengen(495); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495}); + + dieListe.einfuegenBei(18, 808); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495}); + + dieListe.einfuegenBei(2, 811); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495}); + + dieListe.anhaengen(462); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462}); + + dieListe.einfuegenBei(30, 809); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462}); + + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.anhaengen(52); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52}); + + assertTrue("Fehler: Element 972 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(972)); + dieListe.einfuegenBei(46, 982); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52}); + + dieListe.einfuegenBei(5, 117); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347}); + + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347, 867}); + + dieListe.einfuegenBei(20, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347, 867}); + + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347, 867, 822}); + + dieListe.einfuegenBei(65, 295); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 295, 52, 347, 867, 822}); + + dieListe.anhaengen(849); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 295, 52, 347, 867, 822, 849}); + + dieListe.anhaengen(447); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 295, 52, 347, 867, 822, 849, 447}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{688}); + + dieListe.einfuegenBei(1, 958); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958}); + + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958, 672}); + + assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958, 672, 816}); + + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958, 672, 816, 797}); + + assertTrue("Fehler: Element 797 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(797)); + dieListe.einfuegenBei(0, 316); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 672, 816, 797}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 672, 816, 797, 469}); + + assertFalse("Fehler: Element 549 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(549)); + dieListe.einfuegenBei(3, 408); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469}); + + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 271}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 271, 679}); + + dieListe.einfuegenBei(8, 18); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 18, 271, 679}); + + dieListe.einfuegenBei(9, 899); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 18, 899, 271, 679}); + + dieListe.einfuegenBei(12, 761); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 18, 899, 271, 679, 761}); + + dieListe.einfuegenBei(8, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 679, 761}); + + dieListe.einfuegenBei(14, 112); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 679, 761, 112}); + + dieListe.einfuegenBei(12, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 112}); + + dieListe.einfuegenBei(2, 952); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 112}); + + assertTrue("Fehler: Element 316 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(316)); + assertFalse("Fehler: Element 136 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(136)); + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.einfuegenBei(16, 235); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 235, 112}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 235, 112, 411}); + + dieListe.einfuegenBei(5, 583); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 235, 112, 411}); + + dieListe.einfuegenBei(12, 187); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 235, 112, 411}); + + dieListe.anhaengen(717); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 235, 112, 411, 717}); + + dieListe.einfuegenBei(18, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717}); + + dieListe.anhaengen(177); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717, 177}); + + dieListe.anhaengen(814); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717, 177, 814}); + + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717, 177, 814, 487}); + + dieListe.einfuegenBei(17, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487}); + + dieListe.anhaengen(205); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205}); + + dieListe.einfuegenBei(11, 999); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205}); + + assertFalse("Fehler: Element 101 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(101)); + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194}); + + dieListe.einfuegenBei(19, 690); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194}); + + dieListe.einfuegenBei(8, 735); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194}); + + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812}); + + assertFalse("Fehler: Element 957 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(957)); + dieListe.einfuegenBei(16, 204); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812}); + + dieListe.anhaengen(563); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812, 563}); + + dieListe.einfuegenBei(13, 597); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812, 563}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + dieListe.anhaengen(323); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812, 563, 323}); + + dieListe.einfuegenBei(32, 892); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323}); + + assertFalse("Fehler: Element 366 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(366)); + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77}); + + dieListe.anhaengen(237); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237}); + + dieListe.anhaengen(781); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.einfuegenBei(14, 286); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.einfuegenBei(9, 290); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.einfuegenBei(4, 279); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.anhaengen(18); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781, 18}); + + assertTrue("Fehler: Element 408 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(408)); + dieListe.einfuegenBei(36, 228); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18}); + + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18, 290}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18, 290, 576}); + + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604}); + + dieListe.einfuegenBei(39, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604}); + + assertTrue("Fehler: Element 604 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(604)); + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + dieListe.einfuegenBei(10, 320); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958}); + + dieListe.anhaengen(252); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646}); + + dieListe.einfuegenBei(33, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646}); + + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767}); + + assertFalse("Fehler: Element 389 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(389)); + dieListe.anhaengen(161); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161}); + + assertTrue("Fehler: Element 767 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(767)); + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + dieListe.einfuegenBei(29, 971); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161}); + + dieListe.anhaengen(459); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(35); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35}); + + assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191}); + + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606}); + + dieListe.anhaengen(556); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556}); + + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812}); + + dieListe.anhaengen(993); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993}); + + assertTrue("Fehler: Element 812 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(812)); + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + dieListe.einfuegenBei(4, 475); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619}); + + assertFalse("Fehler: Element 123 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(123)); + dieListe.einfuegenBei(24, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619}); + + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + dieListe.einfuegenBei(6, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 380, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + dieListe.einfuegenBei(48, 639); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 380, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 639, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + assertFalse("Fehler: Element 817 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(817)); + dieListe.einfuegenBei(39, 49); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 380, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 49, 814, 487, 892, 228, 205, 194, 920, 812, 563, 639, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{328}); + + dieListe.einfuegenBei(1, 224); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 224}); + + dieListe.anhaengen(431); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 224, 431}); + + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 224, 431, 936}); + + dieListe.einfuegenBei(1, 399); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 431, 936}); + + dieListe.anhaengen(424); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 431, 936, 424}); + + dieListe.einfuegenBei(3, 844); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424}); + + dieListe.anhaengen(486); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486}); + + dieListe.anhaengen(60); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486, 60}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486, 60, 581}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486, 60, 581, 664}); + + dieListe.einfuegenBei(4, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 486, 60, 581, 664}); + + dieListe.einfuegenBei(8, 488); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664, 845}); + + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725}); + + dieListe.anhaengen(830); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + dieListe.einfuegenBei(5, 728); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + assertTrue("Fehler: Element 936 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(936)); + dieListe.einfuegenBei(0, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{798, 328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.einfuegenBei(0, 786); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 816}); + + assertTrue("Fehler: Element 424 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(424)); + dieListe.einfuegenBei(3, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 816}); + + assertFalse("Fehler: Element 528 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(528)); + assertFalse("Fehler: Element 540 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(540)); + dieListe.einfuegenBei(20, 869); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 869, 816}); + + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 869, 816, 954}); + + dieListe.einfuegenBei(18, 153); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954}); + + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633}); + + assertTrue("Fehler: Element 830 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(830)); + dieListe.einfuegenBei(4, 946); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633}); + + dieListe.einfuegenBei(3, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633}); + + assertTrue("Fehler: Element 60 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(60)); + dieListe.anhaengen(665); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665}); + + dieListe.anhaengen(851); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851}); + + assertFalse("Fehler: Element 305 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(305)); + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312}); + + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312, 595}); + + dieListe.einfuegenBei(2, 213); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312, 595}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312, 595, 247}); + + dieListe.einfuegenBei(29, 294); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247}); + + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536}); + + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322}); + + dieListe.anhaengen(524); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852}); + + assertTrue("Fehler: Element 399 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(399)); + dieListe.einfuegenBei(14, 181); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852}); + + dieListe.einfuegenBei(25, 585); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852}); + + assertTrue("Fehler: Element 852 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(852)); + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121}); + + assertFalse("Fehler: Element 343 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(343)); + dieListe.einfuegenBei(12, 431); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121}); + + dieListe.einfuegenBei(10, 493); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121, 539}); + + assertFalse("Fehler: Element 532 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(532)); + dieListe.einfuegenBei(33, 563); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121, 539}); + + dieListe.anhaengen(980); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121, 539, 980}); + + assertTrue("Fehler: Element 328 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(328)); + dieListe.einfuegenBei(43, 856); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980}); + + dieListe.anhaengen(167); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 167}); + + dieListe.einfuegenBei(34, 700); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 167}); + + dieListe.einfuegenBei(48, 977); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.einfuegenBei(1, 592); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + assertTrue("Fehler: Element 830 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(830)); + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + dieListe.einfuegenBei(24, 684); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + dieListe.einfuegenBei(19, 401); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + dieListe.einfuegenBei(24, 737); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + assertFalse("Fehler: Element 987 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(987)); + dieListe.einfuegenBei(49, 675); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347}); + + dieListe.einfuegenBei(6, 897); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347}); + + dieListe.anhaengen(517); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + assertTrue("Fehler: Element 665 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(665)); + dieListe.einfuegenBei(28, 793); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + dieListe.einfuegenBei(16, 616); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + assertTrue("Fehler: Element 224 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(224)); + dieListe.einfuegenBei(13, 279); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + dieListe.anhaengen(785); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785}); + + dieListe.einfuegenBei(37, 104); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785}); + + dieListe.anhaengen(398); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398}); + + assertTrue("Fehler: Element 424 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(424)); + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + assertFalse("Fehler: Element 222 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(222)); + dieListe.anhaengen(173); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173}); + + dieListe.einfuegenBei(34, 107); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173}); + + assertTrue("Fehler: Element 213 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(213)); + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699}); + + dieListe.einfuegenBei(51, 209); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699}); + + dieListe.einfuegenBei(6, 902); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699}); + + assertTrue("Fehler: Element 539 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(539)); + assertTrue("Fehler: Element 60 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(60)); + assertTrue("Fehler: Element 946 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(946)); + dieListe.anhaengen(119); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119}); + + dieListe.einfuegenBei(15, 870); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 870, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119}); + + assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52)); + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 870, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119, 992}); + + dieListe.anhaengen(514); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 870, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119, 992, 514}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 25); + Tester.pruefeListenInhalt(dieListe, new int[]{25}); + + dieListe.anhaengen(550); + Tester.pruefeListenInhalt(dieListe, new int[]{25, 550}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{25, 550, 359}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + assertTrue("Fehler: Element 25 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(25)); + dieListe.einfuegenBei(0, 671); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 25, 550, 359}); + + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 25, 550, 359, 425}); + + dieListe.einfuegenBei(1, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 880, 25, 550, 359, 425}); + + assertFalse("Fehler: Element 955 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(955)); + dieListe.einfuegenBei(3, 478); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 880, 25, 478, 550, 359, 425}); + + dieListe.einfuegenBei(4, 284); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 880, 25, 478, 284, 550, 359, 425}); + + dieListe.einfuegenBei(1, 776); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 880, 25, 478, 284, 550, 359, 425}); + + dieListe.einfuegenBei(2, 928); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425}); + + assertFalse("Fehler: Element 174 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(174)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395}); + + assertFalse("Fehler: Element 830 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(830)); + assertTrue("Fehler: Element 284 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(284)); + dieListe.anhaengen(551); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395, 551}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395, 551, 874}); + + dieListe.anhaengen(819); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395, 551, 874, 819}); + + dieListe.einfuegenBei(8, 406); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 425, 395, 551, 874, 819}); + + dieListe.einfuegenBei(12, 989); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 425, 395, 989, 551, 874, 819}); + + dieListe.anhaengen(235); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 425, 395, 989, 551, 874, 819, 235}); + + dieListe.einfuegenBei(10, 340); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 340, 425, 395, 989, 551, 874, 819, 235}); + + dieListe.einfuegenBei(9, 422); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + dieListe.anhaengen(140); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186}); + + assertFalse("Fehler: Element 514 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(514)); + dieListe.anhaengen(522); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186, 522}); + + assertFalse("Fehler: Element 540 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(540)); + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186, 522, 921}); + + dieListe.einfuegenBei(10, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 396, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186, 522, 921}); + + assertFalse("Fehler: Element 938 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(938)); + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + dieListe.einfuegenBei(19, 10); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 396, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + dieListe.einfuegenBei(11, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 396, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + dieListe.einfuegenBei(7, 318); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 318, 550, 406, 422, 396, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + assertTrue("Fehler: Element 318 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(318)); + dieListe.einfuegenBei(12, 308); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.einfuegenBei(7, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 599, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.einfuegenBei(6, 660); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.einfuegenBei(17, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + assertFalse("Fehler: Element 499 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(499)); + assertFalse("Fehler: Element 997 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(997)); + dieListe.einfuegenBei(9, 49); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507}); + + assertTrue("Fehler: Element 235 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(235)); + assertFalse("Fehler: Element 89 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(89)); + dieListe.einfuegenBei(34, 393); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507, 393}); + + dieListe.anhaengen(836); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507, 393, 836}); + + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507, 393, 836, 23}); + + assertTrue("Fehler: Element 422 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(422)); + dieListe.einfuegenBei(31, 621); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 23}); + + assertFalse("Fehler: Element 771 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(771)); + dieListe.anhaengen(925); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 23, 925}); + + dieListe.einfuegenBei(24, 67); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 23, 925}); + + dieListe.einfuegenBei(38, 832); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 832, 23, 925}); + + assertFalse("Fehler: Element 435 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(435)); + dieListe.anhaengen(162); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 832, 23, 925, 162}); + + dieListe.einfuegenBei(36, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162}); + + dieListe.einfuegenBei(31, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162}); + + dieListe.anhaengen(754); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754}); + + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439}); + + dieListe.einfuegenBei(20, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439}); + + dieListe.anhaengen(597); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597}); + + dieListe.einfuegenBei(31, 485); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351}); + + assertTrue("Fehler: Element 874 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(874)); + dieListe.einfuegenBei(35, 779); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351}); + + dieListe.anhaengen(405); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405}); + + dieListe.einfuegenBei(24, 576); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405}); + + assertTrue("Fehler: Element 406 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(406)); + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575}); + + assertFalse("Fehler: Element 512 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(512)); + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.einfuegenBei(23, 857); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575}); + + dieListe.anhaengen(697); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697}); + + assertFalse("Fehler: Element 57 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(57)); + dieListe.anhaengen(354); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354}); + + assertTrue("Fehler: Element 597 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(597)); + assertTrue("Fehler: Element 162 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(162)); + dieListe.einfuegenBei(15, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354}); + + assertFalse("Fehler: Element 139 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(139)); + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 207}); + + assertFalse("Fehler: Element 191 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(191)); + dieListe.einfuegenBei(58, 190); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207}); + + dieListe.einfuegenBei(37, 358); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207}); + + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.einfuegenBei(3, 716); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207}); + + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845}); + + dieListe.anhaengen(249); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845, 249}); + + dieListe.einfuegenBei(44, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 874, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845, 249}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 874, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845, 249, 557}); + + assertTrue("Fehler: Element 67 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(67)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{442}); + + dieListe.einfuegenBei(0, 475); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442}); + + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474}); + + dieListe.anhaengen(8); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8}); + + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921}); + + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921, 786}); + + assertFalse("Fehler: Element 885 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(885)); + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921, 786, 570}); + + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921, 786, 570, 263}); + + dieListe.einfuegenBei(1, 865); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 474, 8, 921, 786, 570, 263}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 474, 8, 921, 786, 570, 263, 315}); + + dieListe.einfuegenBei(3, 128); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 128, 474, 8, 921, 786, 570, 263, 315}); + + dieListe.einfuegenBei(3, 892); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 8, 921, 786, 570, 263, 315}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 8, 921, 786, 570, 263, 315, 502}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 8, 921, 786, 570, 263, 315, 502, 626}); + + assertTrue("Fehler: Element 475 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(475)); + assertFalse("Fehler: Element 312 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(312)); + assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892)); + assertTrue("Fehler: Element 442 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(442)); + assertTrue("Fehler: Element 8 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(8)); + dieListe.einfuegenBei(6, 68); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 263, 315, 502, 626}); + + dieListe.anhaengen(493); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 263, 315, 502, 626, 493}); + + dieListe.anhaengen(232); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 263, 315, 502, 626, 493, 232}); + + assertTrue("Fehler: Element 263 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(263)); + dieListe.einfuegenBei(11, 923); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 263, 315, 502, 626, 493, 232}); + + dieListe.einfuegenBei(18, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 263, 315, 502, 626, 493, 232, 467}); + + assertTrue("Fehler: Element 570 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(570)); + assertTrue("Fehler: Element 315 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(315)); + dieListe.anhaengen(240); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 263, 315, 502, 626, 493, 232, 467, 240}); + + dieListe.einfuegenBei(12, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 232, 467, 240}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 232, 467, 240, 262}); + + assertFalse("Fehler: Element 879 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(879)); + assertTrue("Fehler: Element 442 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(442)); + assertFalse("Fehler: Element 488 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(488)); + dieListe.einfuegenBei(18, 54); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 54, 232, 467, 240, 262}); + + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 54, 232, 467, 240, 262, 922}); + + dieListe.einfuegenBei(14, 895); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 232, 467, 240, 262, 922}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 232, 467, 240, 262, 922, 302}); + + dieListe.einfuegenBei(20, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539}); + + dieListe.einfuegenBei(17, 102); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539}); + + dieListe.einfuegenBei(5, 943); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539}); + + assertFalse("Fehler: Element 72 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(72)); + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); + assertTrue("Fehler: Element 539 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(539)); + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603}); + + dieListe.anhaengen(886); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886}); + + dieListe.anhaengen(658); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658}); + + dieListe.anhaengen(72); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72}); + + dieListe.einfuegenBei(18, 127); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 127, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72}); + + dieListe.anhaengen(808); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 127, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72, 808}); + + dieListe.einfuegenBei(19, 704); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72, 808}); + + dieListe.einfuegenBei(12, 905); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72, 808}); + + dieListe.einfuegenBei(34, 241); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808}); + + assertFalse("Fehler: Element 801 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(801)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286}); + + dieListe.einfuegenBei(25, 802); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286}); + + dieListe.anhaengen(20); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20}); + + dieListe.anhaengen(374); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374}); + + dieListe.anhaengen(579); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579}); + + dieListe.anhaengen(917); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579, 917}); + + assertTrue("Fehler: Element 54 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(54)); + assertFalse("Fehler: Element 32 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(32)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72)); + dieListe.anhaengen(580); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579, 917, 580}); + + dieListe.anhaengen(600); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579, 917, 580, 600}); + + dieListe.einfuegenBei(42, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600}); + + dieListe.einfuegenBei(13, 179); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600}); + + assertFalse("Fehler: Element 277 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(277)); + assertFalse("Fehler: Element 654 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(654)); + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521}); + + assertTrue("Fehler: Element 603 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(603)); + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22}); + + dieListe.einfuegenBei(34, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22}); + + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799}); + + assertFalse("Fehler: Element 827 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(827)); + dieListe.einfuegenBei(28, 690); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799}); + + assertTrue("Fehler: Element 128 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(128)); + assertFalse("Fehler: Element 590 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(590)); + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881}); + + dieListe.einfuegenBei(18, 821); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881}); + + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881, 369}); + + dieListe.anhaengen(158); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881, 369, 158}); + + dieListe.anhaengen(228); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881, 369, 158, 228}); + + dieListe.einfuegenBei(56, 538); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228}); + + assertTrue("Fehler: Element 179 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(179)); + assertTrue("Fehler: Element 580 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(580)); + dieListe.einfuegenBei(38, 412); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228}); + + dieListe.anhaengen(181); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181}); + + assertTrue("Fehler: Element 865 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(865)); + assertTrue("Fehler: Element 579 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(579)); + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854}); + + assertTrue("Fehler: Element 475 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(475)); + dieListe.anhaengen(56); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56}); + + dieListe.anhaengen(582); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56, 582}); + + dieListe.einfuegenBei(41, 677); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 677, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56, 582}); + + assertTrue("Fehler: Element 228 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(228)); + dieListe.anhaengen(352); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 677, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56, 582, 352}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(744); + Tester.pruefeListenInhalt(dieListe, new int[]{744}); + + dieListe.einfuegenBei(0, 168); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 793}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 793, 957}); + + dieListe.einfuegenBei(2, 275); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957, 529}); + + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957, 529, 969}); + + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957, 529, 969, 625}); + + dieListe.einfuegenBei(1, 570); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625}); + + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 434}); + + assertFalse("Fehler: Element 82 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(82)); + dieListe.einfuegenBei(9, 634); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 634, 434}); + + dieListe.einfuegenBei(9, 56); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 56, 634, 434}); + + dieListe.einfuegenBei(11, 646); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 56, 634, 646, 434}); + + dieListe.anhaengen(274); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 56, 634, 646, 434, 274}); + + dieListe.einfuegenBei(8, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274}); + + dieListe.anhaengen(396); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396}); + + assertTrue("Fehler: Element 625 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(625)); + dieListe.anhaengen(32); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793}); + + dieListe.einfuegenBei(18, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 413}); + + dieListe.anhaengen(948); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 413, 948}); + + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + dieListe.einfuegenBei(18, 514); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 514, 413, 948}); + + dieListe.anhaengen(85); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 514, 413, 948, 85}); + + dieListe.einfuegenBei(15, 596); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85}); + + assertFalse("Fehler: Element 142 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(142)); + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + assertTrue("Fehler: Element 793 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(793)); + assertFalse("Fehler: Element 517 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(517)); + assertTrue("Fehler: Element 435 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(435)); + dieListe.anhaengen(638); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638}); + + assertTrue("Fehler: Element 168 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(168)); + dieListe.einfuegenBei(24, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842}); + + dieListe.einfuegenBei(3, 882); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842}); + + assertTrue("Fehler: Element 434 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(434)); + assertTrue("Fehler: Element 744 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(744)); + dieListe.einfuegenBei(26, 577); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577}); + + dieListe.einfuegenBei(7, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577, 521}); + + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.einfuegenBei(23, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 758, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.einfuegenBei(16, 768); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 758, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.einfuegenBei(24, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605}); + + assertFalse("Fehler: Element 363 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(363)); + assertFalse("Fehler: Element 706 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(706)); + assertTrue("Fehler: Element 275 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(275)); + assertTrue("Fehler: Element 744 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(744)); + dieListe.einfuegenBei(7, 802); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.anhaengen(841); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605, 841}); + + assertTrue("Fehler: Element 85 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(85)); + dieListe.einfuegenBei(18, 653); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605, 841}); + + dieListe.einfuegenBei(28, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620}); + + assertFalse("Fehler: Element 348 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(348)); + assertFalse("Fehler: Element 437 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(829); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829}); + + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + assertTrue("Fehler: Element 842 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(842)); + dieListe.einfuegenBei(5, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829}); + + dieListe.einfuegenBei(12, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829}); + + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967}); + + dieListe.anhaengen(50); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50}); + + dieListe.anhaengen(705); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705}); + + dieListe.einfuegenBei(23, 125); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705}); + + dieListe.einfuegenBei(45, 670); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670}); + + dieListe.einfuegenBei(17, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787}); + + assertTrue("Fehler: Element 435 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(435)); + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686}); + + dieListe.anhaengen(795); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795}); + + dieListe.anhaengen(733); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795, 733}); + + dieListe.einfuegenBei(14, 209); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795, 733}); + + assertTrue("Fehler: Element 829 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(829)); + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + dieListe.einfuegenBei(25, 834); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 294 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(294)); + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + dieListe.einfuegenBei(45, 584); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 584, 967, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 502 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(502)); + dieListe.einfuegenBei(47, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 696 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(696)); + assertTrue("Fehler: Element 56 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(56)); + dieListe.einfuegenBei(2, 269); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 388 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 144 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(144)); + assertFalse("Fehler: Element 106 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(106)); + dieListe.einfuegenBei(41, 139); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); + dieListe.einfuegenBei(18, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733, 709}); + + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733, 709, 932}); + + dieListe.einfuegenBei(16, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 26, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733, 709, 932}); + + assertFalse("Fehler: Element 911 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(911)); + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{482}); + + dieListe.einfuegenBei(0, 248); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 482}); + + dieListe.einfuegenBei(1, 151); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 151, 482}); + + assertTrue("Fehler: Element 482 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(482)); + dieListe.einfuegenBei(1, 526); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 526, 151, 482}); + + dieListe.einfuegenBei(1, 669); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 669, 526, 151, 482}); + + dieListe.einfuegenBei(0, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 151, 482}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + assertFalse("Fehler: Element 253 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(253)); + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.einfuegenBei(4, 528); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 528, 151, 482}); + + dieListe.einfuegenBei(7, 694); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 528, 151, 482, 694}); + + dieListe.einfuegenBei(4, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 528, 151, 482, 694}); + + dieListe.einfuegenBei(5, 181); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 694}); + + dieListe.anhaengen(825); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 694, 825}); + + dieListe.einfuegenBei(11, 388); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 694, 825, 388}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + assertFalse("Fehler: Element 584 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(584)); + dieListe.einfuegenBei(9, 79); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 79, 694, 825, 388}); + + assertFalse("Fehler: Element 41 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(41)); + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 79, 694, 825, 388, 152}); + + dieListe.einfuegenBei(11, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152}); + + dieListe.einfuegenBei(5, 350); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152}); + + dieListe.einfuegenBei(4, 975); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152}); + + assertFalse("Fehler: Element 963 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(963)); + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625}); + + assertTrue("Fehler: Element 350 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(350)); + dieListe.einfuegenBei(0, 38); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625}); + + dieListe.anhaengen(548); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625, 548}); + + dieListe.einfuegenBei(3, 24); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625, 548}); + + assertFalse("Fehler: Element 626 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(626)); + assertFalse("Fehler: Element 929 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(929)); + dieListe.einfuegenBei(16, 605); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 605, 825, 388, 152, 625, 548}); + + dieListe.einfuegenBei(13, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 605, 825, 388, 152, 625, 548}); + + dieListe.einfuegenBei(17, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 625, 548}); + + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 625, 548, 868}); + + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 625, 548, 868, 797}); + + dieListe.einfuegenBei(22, 155); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797}); + + dieListe.einfuegenBei(0, 50); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797}); + + dieListe.einfuegenBei(3, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797}); + + assertTrue("Fehler: Element 528 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(528)); + assertFalse("Fehler: Element 839 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(839)); + dieListe.anhaengen(128); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128}); + + dieListe.anhaengen(185); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185}); + + assertTrue("Fehler: Element 975 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(975)); + dieListe.einfuegenBei(1, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185, 118}); + + dieListe.einfuegenBei(1, 612); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185, 118}); + + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185, 118, 436}); + + dieListe.einfuegenBei(26, 402); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437}); + + dieListe.anhaengen(462); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462}); + + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.anhaengen(274); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462, 274}); + + dieListe.anhaengen(722); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462, 274, 722}); + + dieListe.anhaengen(875); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462, 274, 722, 875}); + + assertFalse("Fehler: Element 757 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(757)); + assertFalse("Fehler: Element 326 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(326)); + dieListe.einfuegenBei(37, 66); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 66, 462, 274, 722, 875}); + + assertTrue("Fehler: Element 825 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(825)); + dieListe.einfuegenBei(37, 200); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875}); + + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + assertFalse("Fehler: Element 817 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(817)); + dieListe.anhaengen(903); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 903}); + + dieListe.einfuegenBei(33, 590); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 903}); + + assertTrue("Fehler: Element 436 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(436)); + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); + dieListe.einfuegenBei(44, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + dieListe.einfuegenBei(6, 228); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166}); + + dieListe.einfuegenBei(32, 852); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166}); + + assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985)); + assertTrue("Fehler: Element 548 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(548)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340}); + + dieListe.anhaengen(287); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.einfuegenBei(36, 817); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.einfuegenBei(8, 715); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 715, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.einfuegenBei(6, 275); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.anhaengen(354); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354}); + + dieListe.einfuegenBei(11, 210); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354}); + + dieListe.einfuegenBei(25, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354}); + + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + dieListe.einfuegenBei(57, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750}); + + dieListe.einfuegenBei(13, 706); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750}); + + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.einfuegenBei(42, 338); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750}); + + assertFalse("Fehler: Element 0 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(0)); + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900}); + + assertTrue("Fehler: Element 903 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(903)); + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + dieListe.einfuegenBei(23, 730); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900}); + + assertTrue("Fehler: Element 210 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(210)); + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900, 637}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900, 637, 964}); + + dieListe.einfuegenBei(23, 697); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 697, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900, 637, 964}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{126}); + + dieListe.anhaengen(503); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 503}); + + assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503)); + dieListe.einfuegenBei(1, 997); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 997, 503}); + + dieListe.einfuegenBei(0, 376); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 503}); + + assertFalse("Fehler: Element 766 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(766)); + assertFalse("Fehler: Element 10 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(10)); + dieListe.anhaengen(687); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 503, 687}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + dieListe.einfuegenBei(3, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 613, 503, 687}); + + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 613, 503, 687, 118}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 613, 503, 687, 118, 869}); + + dieListe.einfuegenBei(2, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 281, 997, 613, 503, 687, 118, 869}); + + assertFalse("Fehler: Element 945 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(945)); + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 281, 997, 613, 503, 687, 118, 869, 388}); + + dieListe.einfuegenBei(2, 323); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 323, 281, 997, 613, 503, 687, 118, 869, 388}); + + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + dieListe.einfuegenBei(2, 125); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388}); + + assertFalse("Fehler: Element 591 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(591)); + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388, 296}); + + assertTrue("Fehler: Element 281 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(281)); + dieListe.einfuegenBei(1, 590); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388, 296}); + + assertTrue("Fehler: Element 281 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(281)); + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388, 296, 490}); + + dieListe.einfuegenBei(6, 941); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 997, 613, 503, 687, 118, 869, 388, 296, 490}); + + dieListe.einfuegenBei(7, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 997, 613, 503, 687, 118, 869, 388, 296, 490}); + + dieListe.einfuegenBei(14, 491); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 997, 613, 503, 687, 118, 869, 491, 388, 296, 490}); + + dieListe.einfuegenBei(8, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 687, 118, 869, 491, 388, 296, 490}); + + dieListe.anhaengen(630); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 687, 118, 869, 491, 388, 296, 490, 630}); + + dieListe.einfuegenBei(12, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 869, 491, 388, 296, 490, 630}); + + dieListe.einfuegenBei(15, 341); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630}); + + assertTrue("Fehler: Element 416 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(416)); + dieListe.einfuegenBei(0, 628); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + dieListe.einfuegenBei(10, 966); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 416, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + dieListe.einfuegenBei(9, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 416, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95)); + dieListe.einfuegenBei(11, 81); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503)); + dieListe.einfuegenBei(10, 81); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470, 137}); + + assertTrue("Fehler: Element 137 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(137)); + assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778)); + dieListe.einfuegenBei(25, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 137}); + + assertFalse("Fehler: Element 910 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(910)); + assertTrue("Fehler: Element 126 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(126)); + assertTrue("Fehler: Element 323 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(323)); + dieListe.einfuegenBei(18, 711); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 137}); + + dieListe.anhaengen(307); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 137, 307}); + + dieListe.einfuegenBei(30, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307}); + + assertTrue("Fehler: Element 997 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(997)); + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914}); + + assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914, 189}); + + dieListe.einfuegenBei(10, 719); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914, 189}); + + assertTrue("Fehler: Element 997 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(997)); + dieListe.einfuegenBei(13, 63); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914, 189}); + + dieListe.einfuegenBei(35, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189}); + + assertTrue("Fehler: Element 380 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(380)); + dieListe.anhaengen(851); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851}); + + assertFalse("Fehler: Element 508 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(508)); + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100}); + + assertTrue("Fehler: Element 941 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(941)); + assertTrue("Fehler: Element 491 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(491)); + dieListe.einfuegenBei(14, 274); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100}); + + assertTrue("Fehler: Element 687 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(687)); + assertTrue("Fehler: Element 590 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(590)); + dieListe.einfuegenBei(30, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100}); + + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100, 213}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); + assertTrue("Fehler: Element 941 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(941)); + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100, 213, 401}); + + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100, 213, 401, 870}); + + dieListe.einfuegenBei(38, 201); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870}); + + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651}); + + dieListe.anhaengen(508); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372}); + + assertTrue("Fehler: Element 63 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(63)); + dieListe.anhaengen(805); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805}); + + dieListe.einfuegenBei(31, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805}); + + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170}); + + assertFalse("Fehler: Element 263 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(263)); + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496}); + + dieListe.einfuegenBei(34, 331); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496}); + + dieListe.einfuegenBei(38, 318); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496}); + + assertFalse("Fehler: Element 102 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(102)); + dieListe.anhaengen(212); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496, 212}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496, 212, 626}); + + assertFalse("Fehler: Element 927 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(927)); + dieListe.einfuegenBei(34, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 666, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496, 212, 626}); + + assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367)); + dieListe.einfuegenBei(54, 123); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 666, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 123, 170, 490, 496, 212, 626}); + + assertTrue("Fehler: Element 613 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(613)); + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{766}); + + dieListe.einfuegenBei(1, 357); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 357}); + + assertFalse("Fehler: Element 702 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(702)); + dieListe.einfuegenBei(1, 250); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 250, 357}); + + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 250, 357, 965}); + + dieListe.anhaengen(151); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 250, 357, 965, 151}); + + dieListe.einfuegenBei(0, 918); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151}); + + dieListe.anhaengen(175); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151, 175}); + + assertTrue("Fehler: Element 250 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(250)); + dieListe.anhaengen(545); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151, 175, 545}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151, 175, 545, 894}); + + dieListe.einfuegenBei(3, 20); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 20, 357, 965, 151, 175, 545, 894}); + + dieListe.einfuegenBei(4, 365); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 20, 365, 357, 965, 151, 175, 545, 894}); + + dieListe.einfuegenBei(4, 101); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894}); + + assertTrue("Fehler: Element 766 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(766)); + dieListe.einfuegenBei(0, 430); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894}); + + dieListe.anhaengen(655); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894, 655}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894, 655, 105}); + + assertTrue("Fehler: Element 766 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(766)); + dieListe.einfuegenBei(12, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 798, 894, 655, 105}); + + assertTrue("Fehler: Element 101 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(101)); + dieListe.einfuegenBei(12, 317); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 894, 655, 105}); + + dieListe.einfuegenBei(14, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105}); + + assertTrue("Fehler: Element 175 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(175)); + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + dieListe.anhaengen(103); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51}); + + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + dieListe.anhaengen(806); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806}); + + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96}); + + assertTrue("Fehler: Element 655 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(655)); + assertFalse("Fehler: Element 60 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(60)); + dieListe.anhaengen(52); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52}); + + dieListe.einfuegenBei(6, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52}); + + assertTrue("Fehler: Element 365 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(365)); + dieListe.einfuegenBei(10, 457); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52}); + + dieListe.anhaengen(991); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570}); + + dieListe.anhaengen(810); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570, 810}); + + dieListe.anhaengen(761); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570, 810, 761}); + + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570, 810, 761, 618}); + + assertFalse("Fehler: Element 989 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(989)); + dieListe.einfuegenBei(26, 315); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618}); + + dieListe.einfuegenBei(3, 309); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618}); + + assertTrue("Fehler: Element 545 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(545)); + assertTrue("Fehler: Element 20 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(20)); + assertTrue("Fehler: Element 894 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(894)); + dieListe.anhaengen(597); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597}); + + assertFalse("Fehler: Element 328 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(328)); + assertTrue("Fehler: Element 52 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(52)); + assertFalse("Fehler: Element 294 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(294)); + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283}); + + dieListe.anhaengen(809); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809}); + + assertTrue("Fehler: Element 283 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(283)); + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487}); + + dieListe.einfuegenBei(7, 951); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487}); + + assertTrue("Fehler: Element 545 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(545)); + assertFalse("Fehler: Element 816 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(816)); + dieListe.anhaengen(78); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78}); + + dieListe.einfuegenBei(6, 10); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47}); + + dieListe.anhaengen(62); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62}); + + assertTrue("Fehler: Element 357 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(357)); + assertTrue("Fehler: Element 78 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(78)); + dieListe.anhaengen(508); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508}); + + dieListe.einfuegenBei(10, 913); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508}); + + dieListe.einfuegenBei(5, 415); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508}); + + dieListe.anhaengen(199); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199}); + + dieListe.einfuegenBei(35, 505); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199}); + + dieListe.anhaengen(98); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199, 98}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + assertTrue("Fehler: Element 52 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(52)); + dieListe.einfuegenBei(29, 759); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199, 98}); + + dieListe.einfuegenBei(48, 366); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199, 366, 98}); + + dieListe.einfuegenBei(44, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98}); + + dieListe.einfuegenBei(39, 63); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98}); + + assertTrue("Fehler: Element 798 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(798)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391}); + + assertFalse("Fehler: Element 204 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(204)); + assertFalse("Fehler: Element 738 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(738)); + assertTrue("Fehler: Element 913 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(913)); + dieListe.einfuegenBei(17, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450}); + + assertFalse("Fehler: Element 115 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(115)); + assertTrue("Fehler: Element 759 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(759)); + assertTrue("Fehler: Element 457 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(457)); + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39}); + + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + assertTrue("Fehler: Element 51 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305}); + + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650}); + + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + assertTrue("Fehler: Element 415 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(415)); + assertFalse("Fehler: Element 145 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(145)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650, 191}); + + dieListe.anhaengen(761); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650, 191, 761}); + + assertTrue("Fehler: Element 761 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(761)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650, 191, 761, 45}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 901); + Tester.pruefeListenInhalt(dieListe, new int[]{901}); + + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{901, 308}); + + dieListe.einfuegenBei(1, 511); + Tester.pruefeListenInhalt(dieListe, new int[]{901, 511, 308}); + + assertFalse("Fehler: Element 954 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(954)); + dieListe.einfuegenBei(0, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 901, 511, 308}); + + dieListe.einfuegenBei(2, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 901, 758, 511, 308}); + + dieListe.einfuegenBei(1, 787); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 901, 758, 511, 308}); + + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 901, 758, 511, 308, 302}); + + dieListe.einfuegenBei(2, 137); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302}); + + assertTrue("Fehler: Element 137 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(137)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302, 688}); + + dieListe.anhaengen(946); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302, 688, 946}); + + dieListe.anhaengen(222); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302, 688, 946, 222}); + + dieListe.einfuegenBei(4, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + assertTrue("Fehler: Element 511 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(511)); + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341}); + + dieListe.anhaengen(188); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188}); + + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334}); + + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857}); + + assertFalse("Fehler: Element 970 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(970)); + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288}); + + dieListe.einfuegenBei(0, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288}); + + assertFalse("Fehler: Element 737 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(737)); + dieListe.einfuegenBei(19, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220}); + + dieListe.einfuegenBei(1, 853); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220}); + + dieListe.anhaengen(814); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814}); + + dieListe.einfuegenBei(7, 305); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814}); + + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814, 767}); + + dieListe.einfuegenBei(9, 229); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814, 767}); + + dieListe.einfuegenBei(19, 35); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767}); + + dieListe.anhaengen(512); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676}); + + assertFalse("Fehler: Element 916 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(916)); + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466}); + + dieListe.einfuegenBei(13, 101); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466}); + + assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302)); + dieListe.einfuegenBei(16, 381); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466}); + + dieListe.einfuegenBei(31, 434); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496}); + + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846}); + + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 66}); + + assertTrue("Fehler: Element 857 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(857)); + assertTrue("Fehler: Element 633 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(633)); + dieListe.einfuegenBei(34, 945); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66}); + + dieListe.anhaengen(156); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156}); + + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + dieListe.einfuegenBei(24, 65); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + assertFalse("Fehler: Element 922 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(922)); + dieListe.einfuegenBei(3, 39); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + dieListe.einfuegenBei(5, 853); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + assertTrue("Fehler: Element 220 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(220)); + dieListe.einfuegenBei(22, 657); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 657, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302)); + dieListe.anhaengen(821); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 657, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(22, 446); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 446, 657, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + assertFalse("Fehler: Element 463 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(463)); + assertFalse("Fehler: Element 807 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(807)); + dieListe.einfuegenBei(27, 630); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(13, 557); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(22, 740); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(1, 926); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(6, 524); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(14, 943); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.anhaengen(459); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459}); + + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799}); + + dieListe.einfuegenBei(17, 315); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 315, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 315, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799, 469}); + + assertTrue("Fehler: Element 853 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(853)); + assertFalse("Fehler: Element 728 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(728)); + dieListe.einfuegenBei(19, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799, 469}); + + dieListe.einfuegenBei(17, 37); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799, 469}); + + dieListe.einfuegenBei(55, 474); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469}); + + assertFalse("Fehler: Element 947 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(947)); + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + dieListe.anhaengen(999); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999}); + + dieListe.einfuegenBei(29, 549); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999}); + + dieListe.einfuegenBei(60, 556); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556}); + + assertTrue("Fehler: Element 536 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(536)); + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77}); + + dieListe.einfuegenBei(7, 760); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470}); + + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97}); + + dieListe.einfuegenBei(52, 387); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97}); + + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102}); + + assertFalse("Fehler: Element 958 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(958)); + dieListe.einfuegenBei(55, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102}); + + dieListe.einfuegenBei(37, 76); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 76, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102}); + + dieListe.anhaengen(289); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 76, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102, 289}); + + assertTrue("Fehler: Element 37 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(37)); + assertTrue("Fehler: Element 229 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(229)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 76, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102, 289, 395}); + + assertFalse("Fehler: Element 586 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(586)); + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + assertFalse("Fehler: Element 310 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(310)); + assertTrue("Fehler: Element 799 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(799)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest6.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest6.java new file mode 100644 index 0000000..7ce4637 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest6.java @@ -0,0 +1,2762 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest6. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest6 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{651}); + + dieListe.einfuegenBei(1, 576); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 576}); + + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + assertTrue("Fehler: Element 651 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(651)); + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 576, 763}); + + assertFalse("Fehler: Element 586 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(586)); + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 576, 763, 920}); + + dieListe.einfuegenBei(0, 418); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 651, 576, 763, 920}); + + dieListe.anhaengen(781); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 651, 576, 763, 920, 781}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 576, 763, 920, 781}); + + dieListe.anhaengen(304); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 576, 763, 920, 781, 304}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 920, 781, 304}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + assertFalse("Fehler: Element 468 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(468)); + assertTrue("Fehler: Element 781 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(781)); + dieListe.einfuegenBei(0, 223); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 304}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.anhaengen(939); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 304, 939}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 939}); + + dieListe.einfuegenBei(4, 685); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939}); + + dieListe.anhaengen(475); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939, 475}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939}); + + assertTrue("Fehler: Element 418 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(418)); + dieListe.einfuegenBei(7, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939, 598}); + + assertFalse("Fehler: Element 843 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(843)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 920, 685, 781, 939, 598}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 685, 781, 939, 598}); + + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 685, 781, 939, 598, 402}); + + dieListe.einfuegenBei(1, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 36, 763, 685, 781, 939, 598, 402}); + + dieListe.einfuegenBei(0, 13); + Tester.pruefeListenInhalt(dieListe, new int[]{13, 418, 36, 763, 685, 781, 939, 598, 402}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{862}); + + dieListe.einfuegenBei(0, 814); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 862}); + + assertTrue("Fehler: Element 862 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(862)); + dieListe.einfuegenBei(0, 615); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 814, 862}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862}); + + dieListe.einfuegenBei(2, 963); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963}); + + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963, 419}); + + assertTrue("Fehler: Element 862 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(862)); + dieListe.einfuegenBei(4, 371); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963, 419, 371}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 419, 371}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371}); + + assertFalse("Fehler: Element 609 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(609)); + dieListe.anhaengen(641); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371, 641}); + + assertTrue("Fehler: Element 615 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(615)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371}); + + assertTrue("Fehler: Element 615 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(615)); + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952}); + + assertFalse("Fehler: Element 187 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(187)); + assertTrue("Fehler: Element 952 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(952)); + dieListe.anhaengen(133); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133}); + + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133, 958}); + + dieListe.anhaengen(20); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133, 958, 20}); + + assertFalse("Fehler: Element 422 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(422)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{371, 952, 133, 958, 20}); + + assertTrue("Fehler: Element 958 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(958)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(772); + Tester.pruefeListenInhalt(dieListe, new int[]{772}); + + assertFalse("Fehler: Element 224 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(224)); + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{772, 968}); + + dieListe.einfuegenBei(1, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{772, 105, 968}); + + dieListe.einfuegenBei(0, 503); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 968}); + + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + assertFalse("Fehler: Element 803 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(803)); + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + dieListe.anhaengen(74); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 968, 74}); + + dieListe.einfuegenBei(3, 682); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 682, 968, 74}); + + assertTrue("Fehler: Element 772 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(772)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74}); + + assertTrue("Fehler: Element 105 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(105)); + dieListe.einfuegenBei(2, 614); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 614, 682, 968, 74}); + + dieListe.einfuegenBei(0, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74}); + + assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503)); + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + dieListe.anhaengen(878); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74, 878}); + + dieListe.einfuegenBei(8, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74, 878, 185}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 682, 968, 74, 878, 185}); + + assertTrue("Fehler: Element 878 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(878)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74, 878, 185}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74, 185}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 74, 185}); + + assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313)); + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 74, 185, 97}); + + dieListe.einfuegenBei(3, 177); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 185, 97}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 97}); + + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 97, 816}); + + assertTrue("Fehler: Element 105 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(105)); + dieListe.einfuegenBei(5, 180); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 180, 97, 816}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 180, 816}); + + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.einfuegenBei(4, 40); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816}); + + assertFalse("Fehler: Element 849 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(849)); + dieListe.anhaengen(910); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816, 910}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816, 910, 679}); + + assertFalse("Fehler: Element 295 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(295)); + dieListe.einfuegenBei(4, 739); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 739, 40, 74, 180, 816, 910, 679}); + + dieListe.anhaengen(773); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 739, 40, 74, 180, 816, 910, 679, 773}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 810); + Tester.pruefeListenInhalt(dieListe, new int[]{810}); + + dieListe.einfuegenBei(0, 594); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 810}); + + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 810, 914}); + + assertTrue("Fehler: Element 810 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(810)); + assertFalse("Fehler: Element 84 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(84)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914}); + + dieListe.einfuegenBei(2, 791); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791}); + + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154}); + + dieListe.anhaengen(79); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79}); + + dieListe.anhaengen(266); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266}); + + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266, 535}); + + dieListe.einfuegenBei(6, 522); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 522, 266, 535}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266, 535}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 535}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 535, 496}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496}); + + dieListe.anhaengen(192); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192}); + + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192, 723}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192, 723, 299}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 496, 192, 723, 299}); + + assertTrue("Fehler: Element 299 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(299)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 496, 192, 299}); + + assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407)); + dieListe.einfuegenBei(5, 143); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 143, 496, 192, 299}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 143, 496, 192}); + + dieListe.einfuegenBei(4, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 126, 266, 143, 496, 192}); + + dieListe.einfuegenBei(7, 374); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 126, 266, 143, 374, 496, 192}); + + dieListe.einfuegenBei(2, 47); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 154, 79, 126, 266, 143, 374, 496, 192}); + + dieListe.einfuegenBei(8, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.einfuegenBei(3, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.einfuegenBei(3, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 599, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + assertTrue("Fehler: Element 686 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(686)); + dieListe.einfuegenBei(3, 216); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 266, 143, 374, 496, 192}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 374, 496, 192}); + + dieListe.einfuegenBei(10, 865); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 374, 496, 865, 192}); + + assertTrue("Fehler: Element 607 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(607)); + assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914)); + dieListe.einfuegenBei(8, 444); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192, 137}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192, 137, 349}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349}); + + assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914)); + assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156)); + assertTrue("Fehler: Element 349 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(349)); + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318}); + + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318, 700}); + + assertTrue("Fehler: Element 444 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(444)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318, 700}); + + assertTrue("Fehler: Element 216 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(216)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 154, 126, 143, 444, 496, 865, 137, 349, 318, 700}); + + assertFalse("Fehler: Element 597 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(597)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 126, 143, 444, 496, 865, 137, 349, 318, 700}); + + dieListe.einfuegenBei(10, 414); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 126, 143, 444, 496, 865, 137, 414, 349, 318, 700}); + + assertFalse("Fehler: Element 188 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(188)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 414, 349, 318, 700}); + + assertFalse("Fehler: Element 175 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(175)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 414, 349, 700}); + + dieListe.einfuegenBei(9, 515); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 515, 414, 349, 700}); + + dieListe.einfuegenBei(7, 768); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 768, 865, 137, 515, 414, 349, 700}); + + dieListe.einfuegenBei(7, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 82, 768, 865, 137, 515, 414, 349, 700}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 82, 768, 865, 515, 414, 349, 700}); + + dieListe.einfuegenBei(4, 443); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 82, 768, 865, 515, 414, 349, 700}); + + dieListe.einfuegenBei(8, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700}); + + dieListe.einfuegenBei(3, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700}); + + assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553)); + dieListe.anhaengen(503); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700, 503}); + + dieListe.anhaengen(665); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700, 503, 665}); + + dieListe.einfuegenBei(14, 923); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 700, 503, 665}); + + assertFalse("Fehler: Element 274 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(274)); + assertTrue("Fehler: Element 713 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(713)); + assertFalse("Fehler: Element 138 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(138)); + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 700, 503, 665, 518}); + + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518, 758}); + + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 758}); + + assertFalse("Fehler: Element 662 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(662)); + dieListe.anhaengen(578); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 758, 578}); + + dieListe.einfuegenBei(18, 349); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578}); + + dieListe.einfuegenBei(11, 961); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166}); + + assertFalse("Fehler: Element 776 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(776)); + dieListe.einfuegenBei(8, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 713, 665, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{588}); + + assertFalse("Fehler: Element 942 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(942)); + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{264}); + + dieListe.einfuegenBei(1, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{264, 842}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{709}); + + assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709)); + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 962); + Tester.pruefeListenInhalt(dieListe, new int[]{962}); + + dieListe.einfuegenBei(0, 257); + Tester.pruefeListenInhalt(dieListe, new int[]{257, 962}); + + dieListe.einfuegenBei(0, 662); + Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 962}); + + dieListe.einfuegenBei(2, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 798, 962}); + + assertFalse("Fehler: Element 327 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(327)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 798}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + + assertTrue("Fehler: Element 70 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(70)); + assertTrue("Fehler: Element 70 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(70)); + assertFalse("Fehler: Element 181 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(181)); + assertFalse("Fehler: Element 741 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(741)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{890}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{465}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{465, 118}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{118}); + + dieListe.einfuegenBei(1, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665}); + + assertTrue("Fehler: Element 665 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(665)); + dieListe.einfuegenBei(2, 90); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 90}); + + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 90, 998}); + + dieListe.anhaengen(60); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 90, 998, 60}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60}); + + dieListe.anhaengen(365); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60, 365}); + + dieListe.einfuegenBei(1, 45); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 45, 665, 998, 60, 365}); + + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 45, 665, 998, 60, 365, 275}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60, 365, 275}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{69}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(612); + Tester.pruefeListenInhalt(dieListe, new int[]{612}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{417}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{595}); + + dieListe.einfuegenBei(0, 939); + Tester.pruefeListenInhalt(dieListe, new int[]{939, 595}); + + assertTrue("Fehler: Element 939 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(939)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 141); + Tester.pruefeListenInhalt(dieListe, new int[]{141}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{141, 570}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{570}); + + assertFalse("Fehler: Element 263 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(263)); + assertFalse("Fehler: Element 448 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(448)); + assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95)); + dieListe.einfuegenBei(1, 684); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 684}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 684, 264}); + + dieListe.einfuegenBei(1, 478); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 478, 684, 264}); + + dieListe.einfuegenBei(1, 300); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 300, 478, 684, 264}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{300, 478, 684, 264}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + assertTrue("Fehler: Element 684 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(684)); + assertTrue("Fehler: Element 478 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(478)); + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{300, 478, 684, 264, 308}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 264, 308}); + + assertTrue("Fehler: Element 684 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(684)); + dieListe.einfuegenBei(4, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 264, 308, 743}); + + assertFalse("Fehler: Element 825 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(825)); + dieListe.einfuegenBei(2, 721); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 721, 264, 308, 743}); + + dieListe.einfuegenBei(2, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 721, 264, 308, 743}); + + dieListe.einfuegenBei(4, 214); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 721, 214, 264, 308, 743}); + + dieListe.einfuegenBei(3, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 214, 264, 308, 743}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 743}); + + dieListe.einfuegenBei(7, 845); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743}); + + dieListe.anhaengen(371); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743, 371}); + + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743, 371, 606}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 371, 606}); + + assertFalse("Fehler: Element 196 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(196)); + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 606}); + + assertTrue("Fehler: Element 721 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(721)); + dieListe.anhaengen(817); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 606, 817}); + + dieListe.einfuegenBei(7, 575); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 606, 817}); + + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 606}); + + dieListe.einfuegenBei(9, 704); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 704, 606}); + + dieListe.einfuegenBei(9, 587); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 587, 704, 606}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 721, 264, 308, 575, 845, 587, 704, 606}); + + assertFalse("Fehler: Element 910 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(910)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 264, 308, 575, 845, 587, 704, 606}); + + dieListe.einfuegenBei(10, 871); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871}); + + assertTrue("Fehler: Element 704 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(704)); + dieListe.einfuegenBei(1, 600); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 600, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871}); + + dieListe.einfuegenBei(1, 910); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 600, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 600, 688, 144, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.einfuegenBei(2, 326); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 600, 688, 144, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 144, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871, 866}); + + dieListe.anhaengen(406); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871, 866, 406}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406}); + + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954}); + + dieListe.einfuegenBei(2, 916); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954}); + + dieListe.anhaengen(483); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954, 483}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483}); + + assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477)); + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483, 280}); + + assertFalse("Fehler: Element 307 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(307)); + dieListe.anhaengen(424); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483, 280, 424}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 931); + Tester.pruefeListenInhalt(dieListe, new int[]{931}); + + assertFalse("Fehler: Element 999 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(999)); + dieListe.anhaengen(829); + Tester.pruefeListenInhalt(dieListe, new int[]{931, 829}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{829}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 737); + Tester.pruefeListenInhalt(dieListe, new int[]{737}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 412); + Tester.pruefeListenInhalt(dieListe, new int[]{412}); + + dieListe.anhaengen(455); + Tester.pruefeListenInhalt(dieListe, new int[]{412, 455}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{412}); + + dieListe.einfuegenBei(1, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{412, 884}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{884}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 995); + Tester.pruefeListenInhalt(dieListe, new int[]{995}); + + dieListe.einfuegenBei(1, 304); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304}); + + dieListe.anhaengen(220); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 220}); + + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 220, 348}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 348}); + + assertFalse("Fehler: Element 706 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(706)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 348}); + + dieListe.anhaengen(944); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 348, 944}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944}); + + dieListe.einfuegenBei(1, 372); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 372, 944}); + + assertTrue("Fehler: Element 944 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(944)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225}); + + dieListe.einfuegenBei(1, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225}); + + assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225)); + dieListe.anhaengen(693); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 693}); + + dieListe.einfuegenBei(4, 543); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 543, 693}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 543, 693, 718}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225, 543, 693, 718}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225, 543, 693, 718, 896}); + + assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225)); + dieListe.einfuegenBei(0, 159); + Tester.pruefeListenInhalt(dieListe, new int[]{159, 304, 944, 225, 543, 693, 718, 896}); + + dieListe.einfuegenBei(4, 199); + Tester.pruefeListenInhalt(dieListe, new int[]{159, 304, 944, 225, 199, 543, 693, 718, 896}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + assertTrue("Fehler: Element 896 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(896)); + dieListe.einfuegenBei(0, 317); + Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896}); + + dieListe.anhaengen(858); + Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858, 581}); + + dieListe.einfuegenBei(0, 97); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858, 581}); + + dieListe.einfuegenBei(4, 667); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 858, 581}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 581}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 581, 267}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267}); + + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267, 368}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267, 368, 245}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245}); + + dieListe.anhaengen(371); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245, 371}); + + assertFalse("Fehler: Element 828 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(828)); + dieListe.einfuegenBei(2, 919); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245, 371}); + + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371}); + + dieListe.einfuegenBei(3, 272); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718}); + + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568}); + + assertFalse("Fehler: Element 287 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(287)); + dieListe.einfuegenBei(3, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 874, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568}); + + dieListe.anhaengen(810); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810}); + + assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267)); + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65}); + + dieListe.anhaengen(234); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65, 234}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65, 234, 285}); + + dieListe.einfuegenBei(17, 501); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + dieListe.einfuegenBei(7, 818); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 818, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718)); + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277}); + + dieListe.anhaengen(319); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319}); + + dieListe.anhaengen(190); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + dieListe.einfuegenBei(2, 631); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 631, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + dieListe.einfuegenBei(13, 516); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 631, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + dieListe.entferneBei(21); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446}); + + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + assertTrue("Fehler: Element 818 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(818)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442, 351}); + + assertTrue("Fehler: Element 234 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(234)); + assertTrue("Fehler: Element 922 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(922)); + assertTrue("Fehler: Element 351 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(351)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{157}); + + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 344}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{157}); + + assertTrue("Fehler: Element 157 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(157)); + assertTrue("Fehler: Element 157 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(157)); + assertTrue("Fehler: Element 157 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(157)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{897}); + + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{186}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{186, 758}); + + assertFalse("Fehler: Element 673 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(673)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{186}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{894}); + + dieListe.einfuegenBei(0, 873); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894}); + + dieListe.anhaengen(332); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 332}); + + assertTrue("Fehler: Element 873 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(873)); + assertFalse("Fehler: Element 519 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(519)); + dieListe.einfuegenBei(2, 79); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 79, 332}); + + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 79, 332, 482}); + + assertTrue("Fehler: Element 873 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(873)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{534}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{534, 923}); + + dieListe.einfuegenBei(0, 834); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 534, 923}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 923}); + + assertTrue("Fehler: Element 923 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(923)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 923, 45}); + + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 923, 45, 275}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 993); + Tester.pruefeListenInhalt(dieListe, new int[]{993}); + + dieListe.einfuegenBei(1, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 568}); + + dieListe.einfuegenBei(1, 966); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 966, 568}); + + dieListe.einfuegenBei(1, 131); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568}); + + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568, 863}); + + assertFalse("Fehler: Element 774 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(774)); + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568, 863, 123}); + + dieListe.einfuegenBei(2, 480); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 966, 568, 863, 123}); + + assertFalse("Fehler: Element 873 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(873)); + assertFalse("Fehler: Element 528 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(528)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 568, 863, 123}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 123}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863}); + + dieListe.anhaengen(416); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416}); + + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416, 257}); + + dieListe.anhaengen(823); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416, 257, 823}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(806); + Tester.pruefeListenInhalt(dieListe, new int[]{806}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(610); + Tester.pruefeListenInhalt(dieListe, new int[]{610}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{288}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 98); + Tester.pruefeListenInhalt(dieListe, new int[]{98}); + + dieListe.einfuegenBei(0, 255); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 98}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{255}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(742); + Tester.pruefeListenInhalt(dieListe, new int[]{742}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{742, 403}); + + dieListe.einfuegenBei(0, 236); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403}); + + assertTrue("Fehler: Element 236 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(236)); + dieListe.einfuegenBei(3, 278); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278}); + + assertTrue("Fehler: Element 278 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(278)); + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278, 21}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278, 21, 154}); + + dieListe.einfuegenBei(3, 719); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 719, 278, 21, 154}); + + dieListe.einfuegenBei(7, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 719, 278, 21, 154, 599}); + + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 719, 278, 21, 154, 599}); + + dieListe.einfuegenBei(2, 605); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 605, 719, 278, 21, 154, 599}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599}); + + dieListe.anhaengen(75); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75}); + + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528}); + + dieListe.anhaengen(138); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528, 138}); + + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528, 138, 340}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340}); + + dieListe.anhaengen(744); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340, 744}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340, 744, 719}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 340, 744, 719}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 340, 719}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 719}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 75, 138, 719}); + + dieListe.einfuegenBei(7, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 75, 138, 445, 719}); + + dieListe.einfuegenBei(5, 845); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 445, 719}); + + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 445, 719, 333}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333}); + + dieListe.einfuegenBei(2, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 536, 719, 21, 599, 845, 75, 138, 719, 333}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333}); + + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + dieListe.anhaengen(733); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333, 733}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333, 733, 861}); + + dieListe.einfuegenBei(6, 878); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861}); + + dieListe.einfuegenBei(1, 889); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861}); + + dieListe.anhaengen(939); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939}); + + assertFalse("Fehler: Element 667 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(667)); + dieListe.einfuegenBei(2, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664}); + + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344}); + + dieListe.einfuegenBei(18, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896}); + + dieListe.einfuegenBei(4, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896}); + + dieListe.einfuegenBei(8, 209); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 861, 939, 664, 344, 976, 896}); + + dieListe.einfuegenBei(2, 35); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 35, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 861, 939, 664, 344, 976, 896}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 760); + Tester.pruefeListenInhalt(dieListe, new int[]{760}); + + dieListe.anhaengen(924); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 924}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 924, 276}); + + dieListe.einfuegenBei(1, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 920, 924, 276}); + + dieListe.einfuegenBei(1, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 574, 920, 924, 276}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211, 189}); + + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211, 189, 328}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 924, 276, 528, 900, 211, 189, 328}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 924, 276, 900, 211, 189, 328}); + + dieListe.einfuegenBei(1, 457); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 457, 924, 276, 900, 211, 189, 328}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 924, 276, 900, 211, 189, 328}); + + dieListe.einfuegenBei(7, 459); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 924, 276, 900, 211, 189, 328, 459}); + + dieListe.einfuegenBei(1, 777); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 924, 276, 900, 211, 189, 328, 459}); + + assertFalse("Fehler: Element 59 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(59)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 924, 900, 211, 189, 328, 459}); + + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 900, 211, 189, 328, 459}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 900, 211, 189, 328, 459}); + + dieListe.einfuegenBei(1, 319); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 328, 459}); + + dieListe.anhaengen(477); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 328, 459, 477}); + + dieListe.einfuegenBei(5, 955); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 955, 328, 459, 477}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 211, 189, 955, 328, 459, 477}); + + assertTrue("Fehler: Element 319 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(319)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 211, 189, 955, 328, 477}); + + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + assertFalse("Fehler: Element 839 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(839)); + assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985)); + dieListe.einfuegenBei(2, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 771, 211, 189, 955, 328, 477}); + + assertFalse("Fehler: Element 848 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(848)); + dieListe.einfuegenBei(2, 421); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 421, 771, 211, 189, 955, 328, 477}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 421, 771, 211, 189, 955, 328, 477}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477}); + + assertTrue("Fehler: Element 328 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(328)); + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 852}); + + dieListe.anhaengen(131); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 852, 131}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 131}); + + dieListe.anhaengen(506); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 131, 506}); + + dieListe.einfuegenBei(0, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 319, 771, 211, 189, 955, 328, 477, 131, 506}); + + dieListe.anhaengen(824); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 319, 771, 211, 189, 955, 328, 477, 131, 506, 824}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{16}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + dieListe.einfuegenBei(1, 714); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 714}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{16}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertFalse("Fehler: Element 300 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(300)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{470}); + + assertFalse("Fehler: Element 472 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(472)); + assertFalse("Fehler: Element 603 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(603)); + dieListe.anhaengen(394); + Tester.pruefeListenInhalt(dieListe, new int[]{470, 394}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{470}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(904); + Tester.pruefeListenInhalt(dieListe, new int[]{904}); + + dieListe.anhaengen(504); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 504}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{904}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{774}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 476); + Tester.pruefeListenInhalt(dieListe, new int[]{476}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{132}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{132, 507}); + + assertTrue("Fehler: Element 507 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(507)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 885); + Tester.pruefeListenInhalt(dieListe, new int[]{885}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{885, 526}); + + assertTrue("Fehler: Element 885 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(885)); + assertFalse("Fehler: Element 436 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(436)); + dieListe.einfuegenBei(2, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{885, 526, 174}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{526, 174}); + + dieListe.einfuegenBei(2, 17); + Tester.pruefeListenInhalt(dieListe, new int[]{526, 174, 17}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 17}); + + dieListe.einfuegenBei(1, 828); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17}); + + dieListe.anhaengen(697); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17, 697}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17, 697, 920}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17, 920}); + + dieListe.einfuegenBei(1, 518); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 17, 920}); + + dieListe.einfuegenBei(3, 685); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920}); + + dieListe.anhaengen(396); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920, 396}); + + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920, 396, 763}); + + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + dieListe.einfuegenBei(3, 548); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 17, 920, 396, 763}); + + assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275)); + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 17, 920, 396, 763, 604}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 920, 396, 763, 604}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 920, 396, 763, 604}); + + dieListe.einfuegenBei(2, 345); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 685, 920, 396, 763, 604}); + + dieListe.anhaengen(751); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 685, 920, 396, 763, 604, 751}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 920, 396, 763, 604, 751}); + + assertTrue("Fehler: Element 604 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(604)); + assertFalse("Fehler: Element 953 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(953)); + assertFalse("Fehler: Element 812 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(812)); + dieListe.anhaengen(136); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 920, 396, 763, 604, 751, 136}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(342); + Tester.pruefeListenInhalt(dieListe, new int[]{342}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{771}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{553}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(585); + Tester.pruefeListenInhalt(dieListe, new int[]{585}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 455); + Tester.pruefeListenInhalt(dieListe, new int[]{455}); + + assertFalse("Fehler: Element 286 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(286)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{455, 286}); + + dieListe.einfuegenBei(1, 58); + Tester.pruefeListenInhalt(dieListe, new int[]{455, 58, 286}); + + dieListe.einfuegenBei(0, 438); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 455, 58, 286}); + + dieListe.einfuegenBei(4, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 455, 58, 286, 496}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 58, 286, 496}); + + assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496)); + dieListe.einfuegenBei(1, 162); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 58, 286, 496}); + + dieListe.einfuegenBei(2, 195); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 58, 286, 496}); + + assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 286, 496}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496}); + + dieListe.anhaengen(911); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496, 911}); + + dieListe.anhaengen(986); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496, 911, 986}); + + dieListe.einfuegenBei(3, 102); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 496, 911, 986}); + + assertFalse("Fehler: Element 979 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(979)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 496, 911}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 911}); + + dieListe.anhaengen(858); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 911, 858}); + + dieListe.einfuegenBei(4, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 911, 858}); + + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 911, 858, 102}); + + dieListe.einfuegenBei(5, 998); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 998, 911, 858, 102}); + + dieListe.einfuegenBei(5, 323); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 858, 102}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.einfuegenBei(8, 721); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 858, 102}); + + dieListe.anhaengen(272); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 858, 102, 272}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 102, 272}); + + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 102, 272, 868}); + + assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20)); + dieListe.einfuegenBei(7, 8); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 8, 911, 721, 102, 272, 868}); + + dieListe.einfuegenBei(10, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868}); + + dieListe.einfuegenBei(1, 375); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868}); + + dieListe.einfuegenBei(9, 216); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868}); + + dieListe.anhaengen(692); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868, 692}); + + dieListe.anhaengen(875); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875}); + + dieListe.einfuegenBei(7, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875}); + + assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297)); + assertTrue("Fehler: Element 911 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(911)); + dieListe.einfuegenBei(18, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702}); + + assertTrue("Fehler: Element 692 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(692)); + dieListe.einfuegenBei(19, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707, 57}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707, 57, 896}); + + assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198)); + assertFalse("Fehler: Element 770 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(770)); + dieListe.einfuegenBei(18, 643); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896}); + + assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102)); + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + assertTrue("Fehler: Element 643 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(643)); + dieListe.anhaengen(85); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.einfuegenBei(5, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 794, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.einfuegenBei(2, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.einfuegenBei(1, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102)); + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85, 397}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397}); + + dieListe.anhaengen(491); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397, 491}); + + dieListe.anhaengen(418); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397, 491, 418}); + + dieListe.entferneBei(19); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 85, 397, 491, 418}); + + assertFalse("Fehler: Element 177 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(177)); + assertFalse("Fehler: Element 45 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(45)); + assertFalse("Fehler: Element 310 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(310)); + dieListe.entferneBei(21); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418}); + + assertFalse("Fehler: Element 73 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(73)); + dieListe.anhaengen(30); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30}); + + dieListe.einfuegenBei(7, 226); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30}); + + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + assertFalse("Fehler: Element 395 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(395)); + dieListe.anhaengen(913); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30, 913}); + + dieListe.anhaengen(885); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30, 913, 885}); + + dieListe.einfuegenBei(18, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 397, 491, 418, 30, 913, 885}); + + dieListe.entferneBei(23); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885}); + + dieListe.einfuegenBei(11, 448); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885}); + + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885, 2}); + + dieListe.entferneBei(25); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.einfuegenBei(12, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 8, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.einfuegenBei(19, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.einfuegenBei(15, 611); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + assertFalse("Fehler: Element 902 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(902)); + dieListe.einfuegenBei(2, 327); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 327, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + assertFalse("Fehler: Element 366 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(366)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 327, 647, 413, 323, 998, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + assertFalse("Fehler: Element 319 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(319)); + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 139); + Tester.pruefeListenInhalt(dieListe, new int[]{139}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(364); + Tester.pruefeListenInhalt(dieListe, new int[]{364}); + + assertFalse("Fehler: Element 166 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(166)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 280); + Tester.pruefeListenInhalt(dieListe, new int[]{280}); + + dieListe.einfuegenBei(1, 996); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 996}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{996}); + + assertTrue("Fehler: Element 996 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(996)); + dieListe.einfuegenBei(0, 894); + Tester.pruefeListenInhalt(dieListe, new int[]{894, 996}); + + assertTrue("Fehler: Element 996 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(996)); + dieListe.einfuegenBei(2, 557); + Tester.pruefeListenInhalt(dieListe, new int[]{894, 996, 557}); + + assertFalse("Fehler: Element 980 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(980)); + dieListe.einfuegenBei(0, 472); + Tester.pruefeListenInhalt(dieListe, new int[]{472, 894, 996, 557}); + + dieListe.einfuegenBei(1, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{472, 546, 894, 996, 557}); + + assertFalse("Fehler: Element 788 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(788)); + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.einfuegenBei(0, 31); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 472, 546, 894, 996, 557}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 472, 546, 894, 996}); + + assertTrue("Fehler: Element 894 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(894)); + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 546, 894, 996}); + + assertTrue("Fehler: Element 996 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(996)); + dieListe.einfuegenBei(2, 518); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 546, 518, 894, 996}); + + dieListe.einfuegenBei(1, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 894, 996}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 894, 996, 276}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 996, 276}); + + dieListe.einfuegenBei(2, 388); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 996, 276}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 996, 276, 897}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 276, 897}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 276, 897, 626}); + + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626}); + + assertFalse("Fehler: Element 92 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(92)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45}); + + dieListe.anhaengen(307); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45, 307}); + + dieListe.anhaengen(479); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45, 307, 479}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 626, 45, 307, 479}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479}); + + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479, 712}); + + dieListe.einfuegenBei(8, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479, 766, 712}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 479, 766, 712}); + + assertTrue("Fehler: Element 555 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(555)); + dieListe.einfuegenBei(3, 878); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 878, 546, 897, 45, 479, 766, 712}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{419}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 966); + Tester.pruefeListenInhalt(dieListe, new int[]{966}); + + dieListe.einfuegenBei(1, 116); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116}); + + dieListe.einfuegenBei(0, 856); + Tester.pruefeListenInhalt(dieListe, new int[]{856, 966, 116}); + + dieListe.anhaengen(942); + Tester.pruefeListenInhalt(dieListe, new int[]{856, 966, 116, 942}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116, 942}); + + assertTrue("Fehler: Element 966 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(966)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116, 247}); + + assertFalse("Fehler: Element 803 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(803)); + dieListe.einfuegenBei(1, 747); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 116, 247}); + + dieListe.anhaengen(338); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 116, 247, 338}); + + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 116, 247, 338, 251}); + + assertFalse("Fehler: Element 67 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(67)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 247, 338, 251}); + + dieListe.einfuegenBei(1, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338, 251}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338}); + + assertTrue("Fehler: Element 966 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(966)); + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338, 740}); + + dieListe.einfuegenBei(2, 423); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 747, 247, 338, 740}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 247, 338, 740}); + + assertFalse("Fehler: Element 272 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(272)); + assertTrue("Fehler: Element 740 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(740)); + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 247, 338, 740, 308}); + + assertTrue("Fehler: Element 338 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(338)); + assertFalse("Fehler: Element 607 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(607)); + assertTrue("Fehler: Element 247 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(247)); + assertFalse("Fehler: Element 109 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(109)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 125); + Tester.pruefeListenInhalt(dieListe, new int[]{125}); + + dieListe.einfuegenBei(0, 887); + Tester.pruefeListenInhalt(dieListe, new int[]{887, 125}); + + assertTrue("Fehler: Element 887 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(887)); + assertTrue("Fehler: Element 887 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(887)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{125}); + + assertTrue("Fehler: Element 125 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(125)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{259}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{259, 750}); + + assertFalse("Fehler: Element 268 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(268)); + assertTrue("Fehler: Element 259 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(259)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{259}); + + dieListe.einfuegenBei(1, 456); + Tester.pruefeListenInhalt(dieListe, new int[]{259, 456}); + + dieListe.einfuegenBei(0, 415); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 259, 456}); + + assertFalse("Fehler: Element 797 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(797)); + assertTrue("Fehler: Element 456 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(456)); + dieListe.einfuegenBei(0, 729); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 415, 259, 456}); + + dieListe.einfuegenBei(1, 985); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 985, 415, 259, 456}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 985, 415, 456}); + + dieListe.einfuegenBei(1, 233); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 985, 415, 456}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456}); + + dieListe.einfuegenBei(4, 825); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456, 825}); + + dieListe.einfuegenBei(4, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456, 651, 825}); + + dieListe.einfuegenBei(1, 733); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 733, 233, 415, 456, 651, 825}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(235); + Tester.pruefeListenInhalt(dieListe, new int[]{235}); + + assertTrue("Fehler: Element 235 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(235)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(84); + Tester.pruefeListenInhalt(dieListe, new int[]{84}); + + dieListe.anhaengen(913); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 913}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{84}); + + dieListe.anhaengen(60); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 60}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{84}); + + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 949}); + + assertFalse("Fehler: Element 745 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(745)); + dieListe.einfuegenBei(2, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 949, 633}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{619}); + + assertTrue("Fehler: Element 619 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(619)); + dieListe.einfuegenBei(0, 589); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 619}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{589}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + dieListe.einfuegenBei(1, 407); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407}); + + dieListe.anhaengen(959); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959}); + + dieListe.einfuegenBei(3, 823); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959, 823}); + + assertTrue("Fehler: Element 823 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(823)); + assertFalse("Fehler: Element 975 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(975)); + dieListe.anhaengen(945); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959, 823, 945}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{529}); + + dieListe.anhaengen(258); + Tester.pruefeListenInhalt(dieListe, new int[]{529, 258}); + + assertTrue("Fehler: Element 258 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(258)); + assertFalse("Fehler: Element 384 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(384)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{529}); + + assertTrue("Fehler: Element 529 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(529)); + dieListe.einfuegenBei(1, 770); + Tester.pruefeListenInhalt(dieListe, new int[]{529, 770}); + + assertFalse("Fehler: Element 16 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(16)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{529}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 381); + Tester.pruefeListenInhalt(dieListe, new int[]{381}); + + dieListe.einfuegenBei(1, 342); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342}); + + dieListe.anhaengen(167); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 167}); + + dieListe.einfuegenBei(2, 5); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 5, 167}); + + assertFalse("Fehler: Element 252 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(252)); + assertTrue("Fehler: Element 381 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(381)); + dieListe.einfuegenBei(2, 484); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 484, 5, 167}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 484, 5}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 484, 5}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 5}); + + dieListe.einfuegenBei(2, 724); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 5, 724}); + + dieListe.einfuegenBei(1, 719); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 719, 5, 724}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 719, 5}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 719}); + + dieListe.einfuegenBei(1, 32); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 32, 719}); + + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 32, 719, 482}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 32, 719, 482, 262}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{952}); + + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369}); + + dieListe.anhaengen(182); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369, 182}); + + dieListe.anhaengen(516); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369, 182, 516}); + + assertFalse("Fehler: Element 386 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(386)); + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369, 182, 516, 992}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{689}); + + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{689, 449}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{449}); + + dieListe.einfuegenBei(1, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{449, 757}); + + assertFalse("Fehler: Element 884 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(884)); + assertTrue("Fehler: Element 449 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(449)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{757}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 521}); + + dieListe.einfuegenBei(2, 517); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 521, 517}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 517}); + + dieListe.einfuegenBei(1, 179); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179, 517}); + + assertTrue("Fehler: Element 517 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(517)); + assertTrue("Fehler: Element 757 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(757)); + dieListe.einfuegenBei(1, 129); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 129, 179, 517}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 129, 179}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179}); + + dieListe.anhaengen(628); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179, 628}); + + dieListe.anhaengen(552); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179, 628, 552}); + + assertTrue("Fehler: Element 628 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(628)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{955}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(454); + Tester.pruefeListenInhalt(dieListe, new int[]{454}); + + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{454, 116}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{454}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{652}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 158); + Tester.pruefeListenInhalt(dieListe, new int[]{158}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(938); + Tester.pruefeListenInhalt(dieListe, new int[]{938}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{713}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189}); + + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + dieListe.einfuegenBei(2, 699); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189, 699}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189}); + + dieListe.einfuegenBei(2, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189, 880}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(819); + Tester.pruefeListenInhalt(dieListe, new int[]{819}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{819, 743}); + + dieListe.einfuegenBei(0, 432); + Tester.pruefeListenInhalt(dieListe, new int[]{432, 819, 743}); + + assertTrue("Fehler: Element 432 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(432)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{432, 819}); + + dieListe.einfuegenBei(2, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{432, 819, 91}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{819, 91}); + + assertFalse("Fehler: Element 612 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(612)); + dieListe.einfuegenBei(2, 346); + Tester.pruefeListenInhalt(dieListe, new int[]{819, 91, 346}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 346}); + + dieListe.anhaengen(697); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 346, 697}); + + assertTrue("Fehler: Element 346 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(346)); + assertTrue("Fehler: Element 91 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(91)); + dieListe.einfuegenBei(0, 249); + Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 697}); + + dieListe.einfuegenBei(3, 230); + Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 230, 697}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 230}); + + assertTrue("Fehler: Element 346 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(346)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 346, 230}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 230}); + + dieListe.einfuegenBei(1, 15); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 230}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15}); + + dieListe.anhaengen(230); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 230}); + + dieListe.einfuegenBei(2, 405); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 230}); + + dieListe.anhaengen(497); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 230, 497}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497}); + + dieListe.anhaengen(919); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497, 919}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497, 919, 108}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 405, 497, 919, 108}); + + dieListe.einfuegenBei(1, 197); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 497, 919, 108}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 497, 108}); + + dieListe.einfuegenBei(3, 538); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 538, 497, 108}); + + dieListe.einfuegenBei(1, 875); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108}); + + assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486)); + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108, 896}); + + assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15)); + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108, 896, 786}); + + assertFalse("Fehler: Element 816 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(816)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 108, 896, 786}); + + assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622)); + assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 405, 538, 108, 896, 786}); + + dieListe.anhaengen(512); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 405, 538, 108, 896, 786, 512}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 538, 108, 896, 786, 512}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(181); + Tester.pruefeListenInhalt(dieListe, new int[]{181}); + + assertFalse("Fehler: Element 506 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(506)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{42}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 438); + Tester.pruefeListenInhalt(dieListe, new int[]{438}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 970}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.einfuegenBei(1, 948); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 948}); + + dieListe.anhaengen(149); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 948, 149}); + + dieListe.einfuegenBei(1, 167); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 167, 948, 149}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(785); + Tester.pruefeListenInhalt(dieListe, new int[]{785}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{126}); + + assertFalse("Fehler: Element 519 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(519)); + dieListe.anhaengen(864); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 864}); + + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 864, 168}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 168}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 168, 194}); + + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + dieListe.einfuegenBei(3, 113); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 168, 194, 113}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 194, 113}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 194, 113, 110}); + + assertFalse("Fehler: Element 131 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(131)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110}); + + dieListe.anhaengen(927); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 927}); + + dieListe.einfuegenBei(3, 730); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 730, 927}); + + assertFalse("Fehler: Element 103 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(103)); + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 730, 927, 355}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355}); + + assertTrue("Fehler: Element 730 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(730)); + dieListe.anhaengen(365); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365}); + + dieListe.anhaengen(29); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29, 869}); + + dieListe.anhaengen(246); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29, 869, 246}); + + dieListe.einfuegenBei(4, 508); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 508, 355, 365, 29, 869, 246}); + + dieListe.einfuegenBei(0, 415); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 110, 730, 927, 508, 355, 365, 29, 869, 246}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 869, 246}); + + dieListe.einfuegenBei(8, 506); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246, 862}); + + dieListe.einfuegenBei(11, 299); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246, 299, 862}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 355, 365, 29, 506, 869, 246, 299, 862}); + + assertFalse("Fehler: Element 559 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(559)); + dieListe.einfuegenBei(4, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 59, 355, 365, 29, 506, 869, 246, 299, 862}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.einfuegenBei(1, 531); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + dieListe.einfuegenBei(5, 499); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 499, 59, 355, 365, 29, 506, 246, 299, 862}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + assertTrue("Fehler: Element 927 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(927)); + assertFalse("Fehler: Element 221 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(221)); + assertTrue("Fehler: Element 29 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(29)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest7.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest7.java new file mode 100644 index 0000000..dce19ea --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest7.java @@ -0,0 +1,2841 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest7. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest7 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 0); + Tester.pruefeListenInhalt(dieListe, new int[]{0}); + + dieListe.einfuegenBei(1, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{0, 922}); + + dieListe.einfuegenBei(2, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{0, 922, 956}); + + dieListe.einfuegenBei(0, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 0, 922, 956}); + + dieListe.einfuegenBei(2, 114); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 0, 114, 922, 956}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 0, 114, 956}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956}); + + assertFalse("Fehler: Element 371 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(371)); + dieListe.anhaengen(215); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 718}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 718, 276}); + + dieListe.einfuegenBei(4, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 788, 718, 276}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 788, 718, 276}); + + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 788, 276}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276}); + + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832}); + + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102}); + + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102, 7}); + + assertFalse("Fehler: Element 240 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(240)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102}); + + dieListe.einfuegenBei(0, 393); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 607, 956, 788, 276, 832, 102}); + + dieListe.einfuegenBei(1, 691); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 956, 788, 276, 832, 102}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 276, 832, 102}); + + assertFalse("Fehler: Element 886 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(886)); + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 276, 832, 102, 344}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 102, 344}); + + dieListe.einfuegenBei(5, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 109, 102, 344}); + + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 109, 102, 344, 970}); + + assertFalse("Fehler: Element 766 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(766)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 344, 970}); + + dieListe.einfuegenBei(6, 497); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 344, 970}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 344}); + + assertTrue("Fehler: Element 691 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(691)); + dieListe.einfuegenBei(7, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 665, 344}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + dieListe.einfuegenBei(4, 659); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 109, 102, 497, 665, 344}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 109, 497, 665, 344}); + + dieListe.einfuegenBei(5, 493); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 493, 109, 497, 665, 344}); + + assertTrue("Fehler: Element 344 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(344)); + assertTrue("Fehler: Element 691 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(691)); + assertFalse("Fehler: Element 539 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(539)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 493, 109, 497, 344}); + + dieListe.einfuegenBei(3, 819); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 819, 832, 659, 493, 109, 497, 344}); + + assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672)); + dieListe.einfuegenBei(10, 387); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 819, 832, 659, 493, 109, 497, 344, 387}); + + dieListe.einfuegenBei(3, 805); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 805, 819, 832, 659, 493, 109, 497, 344, 387}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 497, 344, 387}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 344, 387}); + + assertTrue("Fehler: Element 819 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(819)); + dieListe.einfuegenBei(10, 722); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 344, 387, 722}); + + assertFalse("Fehler: Element 39 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(39)); + assertFalse("Fehler: Element 739 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(739)); + dieListe.einfuegenBei(2, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 387, 722}); + + dieListe.einfuegenBei(10, 857); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 857, 387, 722}); + + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 857, 387, 722, 96}); + + dieListe.einfuegenBei(10, 37); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 722, 96}); + + dieListe.anhaengen(426); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 722, 96, 426}); + + dieListe.einfuegenBei(13, 503); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 503, 722, 96, 426}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 503, 722, 96, 426}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 825); + Tester.pruefeListenInhalt(dieListe, new int[]{825}); + + assertTrue("Fehler: Element 825 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(825)); + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627}); + + dieListe.einfuegenBei(0, 945); + Tester.pruefeListenInhalt(dieListe, new int[]{945, 825, 627}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627}); + + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627, 213}); + + dieListe.anhaengen(566); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627, 213, 566}); + + assertFalse("Fehler: Element 97 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(97)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 213, 566}); + + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 213, 566, 280}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 566, 280}); + + assertTrue("Fehler: Element 627 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(627)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 280}); + + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 280, 117}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 117}); + + dieListe.anhaengen(755); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 117, 755}); + + dieListe.einfuegenBei(1, 32); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 755}); + + dieListe.anhaengen(695); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 755, 695}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 695}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 117, 695}); + + dieListe.einfuegenBei(1, 53); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 53, 117, 695}); + + dieListe.einfuegenBei(4, 846); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 53, 117, 695, 846}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846}); + + dieListe.anhaengen(242); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515}); + + dieListe.einfuegenBei(6, 471); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471}); + + dieListe.anhaengen(73); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 73}); + + assertTrue("Fehler: Element 846 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(846)); + assertFalse("Fehler: Element 65 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(65)); + dieListe.einfuegenBei(7, 273); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 273, 73}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 73}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 73}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 73, 99}); + + dieListe.einfuegenBei(2, 644); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 644, 695, 846, 242, 515, 73, 99}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 265); + Tester.pruefeListenInhalt(dieListe, new int[]{265}); + + assertFalse("Fehler: Element 478 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(478)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{357}); + + dieListe.anhaengen(214); + Tester.pruefeListenInhalt(dieListe, new int[]{357, 214}); + + dieListe.einfuegenBei(2, 277); + Tester.pruefeListenInhalt(dieListe, new int[]{357, 214, 277}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{357, 214}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{357}); + + assertFalse("Fehler: Element 291 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(291)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{771}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{771, 619}); + + dieListe.einfuegenBei(2, 245); + Tester.pruefeListenInhalt(dieListe, new int[]{771, 619, 245}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{689}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(977); + Tester.pruefeListenInhalt(dieListe, new int[]{977}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{318}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{318, 413}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{413}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(149); + Tester.pruefeListenInhalt(dieListe, new int[]{149}); + + dieListe.anhaengen(114); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 114}); + + dieListe.einfuegenBei(0, 476); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114}); + + dieListe.anhaengen(323); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323}); + + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 940}); + + assertFalse("Fehler: Element 641 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(641)); + dieListe.einfuegenBei(4, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 59, 940}); + + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + dieListe.anhaengen(488); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 59, 940, 488}); + + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + assertFalse("Fehler: Element 390 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(390)); + dieListe.einfuegenBei(3, 614); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 614, 323, 59, 940, 488}); + + dieListe.einfuegenBei(2, 557); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488}); + + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908}); + + dieListe.anhaengen(155); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908, 155}); + + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908, 155, 596}); + + dieListe.einfuegenBei(5, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 416, 323, 59, 940, 488, 908, 155, 596}); + + dieListe.einfuegenBei(2, 832); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 488, 908, 155, 596}); + + dieListe.einfuegenBei(10, 600); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 600, 488, 908, 155, 596}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 600, 908, 155, 596}); + + dieListe.einfuegenBei(9, 466); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596}); + + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596, 670}); + + dieListe.anhaengen(762); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596, 670, 762}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762}); + + dieListe.einfuegenBei(16, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813}); + + dieListe.anhaengen(759); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813, 759}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813, 759}); + + assertFalse("Fehler: Element 783 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(783)); + dieListe.einfuegenBei(15, 961); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759}); + + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(4, 414); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759, 732}); + + assertTrue("Fehler: Element 832 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(832)); + dieListe.einfuegenBei(14, 879); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(8, 971); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 971, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(9, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(5, 836); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 670, 762, 961, 813, 759, 732}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.entferneBei(22); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 670, 762, 961, 813, 759}); + + dieListe.einfuegenBei(17, 173); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 173, 670, 762, 961, 813, 759}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759}); + + dieListe.einfuegenBei(5, 97); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.einfuegenBei(1, 301); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759}); + + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + dieListe.einfuegenBei(21, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759, 974}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759, 974}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{812}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{812, 57}); + + dieListe.anhaengen(944); + Tester.pruefeListenInhalt(dieListe, new int[]{812, 57, 944}); + + dieListe.anhaengen(400); + Tester.pruefeListenInhalt(dieListe, new int[]{812, 57, 944, 400}); + + assertTrue("Fehler: Element 57 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(57)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{57, 944, 400}); + + assertFalse("Fehler: Element 854 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(854)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{944, 400}); + + dieListe.einfuegenBei(1, 930); + Tester.pruefeListenInhalt(dieListe, new int[]{944, 930, 400}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{944, 930, 400, 626}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 400, 626}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626}); + + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626, 857}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626}); + + dieListe.anhaengen(321); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626, 321}); + + assertTrue("Fehler: Element 930 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(930)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 321}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930}); + + dieListe.einfuegenBei(1, 583); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 583}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 583, 118}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 118}); + + assertFalse("Fehler: Element 152 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(152)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{118}); + + dieListe.einfuegenBei(1, 746); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 746}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(486); + Tester.pruefeListenInhalt(dieListe, new int[]{486}); + + dieListe.anhaengen(44); + Tester.pruefeListenInhalt(dieListe, new int[]{486, 44}); + + assertTrue("Fehler: Element 486 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(486)); + assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44)); + dieListe.einfuegenBei(1, 973); + Tester.pruefeListenInhalt(dieListe, new int[]{486, 973, 44}); + + dieListe.anhaengen(17); + Tester.pruefeListenInhalt(dieListe, new int[]{486, 973, 44, 17}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17}); + + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 126}); + + dieListe.einfuegenBei(4, 515); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 126, 515}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 515}); + + dieListe.anhaengen(239); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 515, 239}); + + dieListe.einfuegenBei(1, 845); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 17, 515, 239}); + + dieListe.einfuegenBei(3, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 462, 17, 515, 239}); + + dieListe.einfuegenBei(3, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 247, 462, 17, 515, 239}); + + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.einfuegenBei(3, 118); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 247, 462, 17, 515, 239}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 247, 462, 17, 239}); + + dieListe.einfuegenBei(4, 201); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 201, 247, 462, 17, 239}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 118, 201, 247, 462, 17, 239}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 118, 201, 247, 462, 17, 239, 51}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 201, 247, 462, 17, 239, 51}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 201, 247, 462, 239, 51}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51}); + + dieListe.anhaengen(694); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51, 694}); + + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51, 694, 700}); + + assertFalse("Fehler: Element 497 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(497)); + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.einfuegenBei(5, 264); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 264, 51, 694, 700}); + + dieListe.einfuegenBei(1, 353); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 353, 201, 247, 462, 239, 264, 51, 694, 700}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 353, 201, 247, 462, 239, 264, 694, 700}); + + dieListe.einfuegenBei(1, 974); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 462, 239, 264, 694, 700}); + + dieListe.einfuegenBei(5, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 874, 462, 239, 264, 694, 700}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 874, 239, 264, 694, 700}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 264, 694, 700}); + + dieListe.einfuegenBei(6, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 694, 700}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 700}); + + assertFalse("Fehler: Element 993 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(993)); + dieListe.anhaengen(882); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 700, 882}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 882}); + + assertFalse("Fehler: Element 680 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(680)); + dieListe.einfuegenBei(2, 340); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 340, 353, 201, 247, 239, 26, 264, 882}); + + assertFalse("Fehler: Element 896 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(896)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 882}); + + dieListe.einfuegenBei(4, 389); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 26, 264, 882}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 26, 264, 882, 299}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299}); + + dieListe.einfuegenBei(3, 195); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 389, 247, 239, 264, 882, 299}); + + assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195)); + dieListe.anhaengen(613); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 389, 247, 239, 264, 882, 299, 613}); + + dieListe.einfuegenBei(5, 611); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 611, 389, 247, 239, 264, 882, 299, 613}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613}); + + dieListe.anhaengen(242); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242}); + + assertFalse("Fehler: Element 75 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(75)); + assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389)); + dieListe.einfuegenBei(13, 140); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140}); + + assertFalse("Fehler: Element 388 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(388)); + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 288}); + + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140}); + + dieListe.anhaengen(352); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352}); + + dieListe.anhaengen(363); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.anhaengen(218); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 644}); + + dieListe.einfuegenBei(16, 756); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644, 900}); + + dieListe.einfuegenBei(15, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 183, 218, 756, 644, 900}); + + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644, 900}); + + dieListe.einfuegenBei(14, 348); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 348, 363, 218, 756, 644, 900}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{43}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 504); + Tester.pruefeListenInhalt(dieListe, new int[]{504}); + + dieListe.einfuegenBei(1, 667); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667}); + + assertFalse("Fehler: Element 187 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(187)); + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452}); + + dieListe.anhaengen(647); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 647}); + + dieListe.einfuegenBei(3, 463); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 463, 647}); + + dieListe.einfuegenBei(3, 826); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 826, 463, 647}); + + dieListe.einfuegenBei(1, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 667, 452, 826, 463, 647}); + + dieListe.einfuegenBei(5, 90); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 667, 452, 826, 90, 463, 647}); + + assertTrue("Fehler: Element 647 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(647)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 452, 826, 90, 463, 647}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 452, 826, 90, 647}); + + assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265)); + dieListe.einfuegenBei(0, 669); + Tester.pruefeListenInhalt(dieListe, new int[]{669, 504, 532, 452, 826, 90, 647}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 454); + Tester.pruefeListenInhalt(dieListe, new int[]{454}); + + dieListe.einfuegenBei(0, 620); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 454}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 454, 450}); + + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 454, 450, 955}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 450, 955}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 450, 955, 292}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 753); + Tester.pruefeListenInhalt(dieListe, new int[]{753}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 61); + Tester.pruefeListenInhalt(dieListe, new int[]{61}); + + assertFalse("Fehler: Element 938 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(938)); + dieListe.anhaengen(705); + Tester.pruefeListenInhalt(dieListe, new int[]{61, 705}); + + dieListe.einfuegenBei(2, 124); + Tester.pruefeListenInhalt(dieListe, new int[]{61, 705, 124}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{61, 705, 124, 920}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{705, 124, 920}); + + dieListe.einfuegenBei(0, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920}); + + dieListe.anhaengen(963); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963}); + + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6}); + + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6, 749}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6, 749, 883}); + + dieListe.einfuegenBei(0, 875); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 963, 6, 749, 883}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 6, 749, 883}); + + dieListe.einfuegenBei(5, 554); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 554, 6, 749, 883}); + + assertFalse("Fehler: Element 165 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 444 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(444)); + dieListe.einfuegenBei(6, 313); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 554, 313, 6, 749, 883}); + + dieListe.einfuegenBei(3, 949); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 6, 749, 883}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 6, 883}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 883}); + + dieListe.einfuegenBei(3, 449); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 920, 554, 313, 883}); + + assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486)); + assertTrue("Fehler: Element 705 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(705)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883}); + + dieListe.einfuegenBei(9, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883, 788}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883, 788, 170}); + + dieListe.einfuegenBei(4, 10); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 554, 313, 883, 788, 170}); + + dieListe.anhaengen(431); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 554, 313, 883, 788, 170, 431}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + assertFalse("Fehler: Element 726 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(726)); + assertTrue("Fehler: Element 875 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(875)); + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + dieListe.einfuegenBei(7, 949); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 554, 313, 883, 788, 170, 431}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 554, 313, 883, 788, 431}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 313, 883, 788, 431}); + + assertTrue("Fehler: Element 875 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(875)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 788, 431}); + + dieListe.einfuegenBei(9, 600); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431}); + + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(212); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 212}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431}); + + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575, 157}); + + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575, 157, 838}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 157, 838}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 157}); + + dieListe.einfuegenBei(12, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 980, 157}); + + dieListe.anhaengen(677); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 980, 157, 677}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 575, 980, 157, 677}); + + dieListe.einfuegenBei(9, 693); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677}); + + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37}); + + dieListe.anhaengen(212); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37, 212}); + + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37, 212, 838}); + + dieListe.einfuegenBei(9, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 980, 157, 677, 37, 212, 838}); + + dieListe.anhaengen(971); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 980, 157, 677, 37, 212, 838, 971}); + + dieListe.einfuegenBei(13, 708); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 677, 37, 212, 838, 971}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 37, 212, 838, 971}); + + dieListe.einfuegenBei(16, 67); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 67, 37, 212, 838, 971}); + + dieListe.einfuegenBei(15, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + + dieListe.einfuegenBei(6, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + + dieListe.einfuegenBei(4, 977); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 977, 949, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + + assertTrue("Fehler: Element 600 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(600)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 977, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(834); + Tester.pruefeListenInhalt(dieListe, new int[]{834}); + + assertTrue("Fehler: Element 834 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(834)); + dieListe.einfuegenBei(0, 657); + Tester.pruefeListenInhalt(dieListe, new int[]{657, 834}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{657}); + + assertTrue("Fehler: Element 657 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(657)); + dieListe.einfuegenBei(1, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{657, 884}); + + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{657, 884, 45}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644}); + + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413}); + + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413, 686}); + + assertFalse("Fehler: Element 804 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(804)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413}); + + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881}); + + dieListe.einfuegenBei(4, 685); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 685}); + + assertFalse("Fehler: Element 87 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(87)); + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 897}); + + dieListe.anhaengen(300); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 897, 300}); + + dieListe.einfuegenBei(1, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 396, 644, 413, 881, 897, 300}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + dieListe.einfuegenBei(6, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 396, 644, 413, 881, 897, 568, 300}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 173); + Tester.pruefeListenInhalt(dieListe, new int[]{173}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 843); + Tester.pruefeListenInhalt(dieListe, new int[]{843}); + + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + assertTrue("Fehler: Element 843 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(843)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{914}); + + dieListe.einfuegenBei(0, 814); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 914}); + + dieListe.einfuegenBei(1, 74); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914}); + + assertFalse("Fehler: Element 787 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(787)); + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914, 846}); + + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914, 846, 95}); + + dieListe.einfuegenBei(0, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 846, 95}); + + dieListe.einfuegenBei(6, 84); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 846, 95, 84}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 95, 84}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 74, 914, 95, 84}); + + assertFalse("Fehler: Element 182 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(182)); + assertFalse("Fehler: Element 495 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(495)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 74, 914, 84}); + + dieListe.einfuegenBei(1, 556); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84}); + + dieListe.einfuegenBei(1, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 813, 556, 74, 914, 84}); + + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 813, 556, 74, 914, 84, 640}); + + assertFalse("Fehler: Element 601 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(601)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640}); + + dieListe.einfuegenBei(1, 365); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640}); + + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 126}); + + dieListe.einfuegenBei(7, 955); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126}); + + dieListe.anhaengen(309); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309}); + + assertFalse("Fehler: Element 638 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(638)); + assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765)); + dieListe.anhaengen(551); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309, 551}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309, 551, 347}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 309, 551, 347}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 551, 347}); + + dieListe.anhaengen(995); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 551, 347, 995}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 551, 347, 995}); + + assertTrue("Fehler: Element 640 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(640)); + assertFalse("Fehler: Element 864 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(864)); + dieListe.einfuegenBei(7, 115); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 115, 551, 347, 995}); + + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 115, 551, 347, 995, 568}); + + dieListe.einfuegenBei(2, 54); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 84, 640, 955, 115, 551, 347, 995, 568}); + + dieListe.einfuegenBei(5, 939); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 939, 84, 640, 955, 115, 551, 347, 995, 568}); + + assertTrue("Fehler: Element 84 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(84)); + dieListe.einfuegenBei(8, 790); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568}); + + assertTrue("Fehler: Element 84 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(84)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589}); + + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589, 83}); + + dieListe.einfuegenBei(9, 267); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83}); + + dieListe.anhaengen(131); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + + dieListe.einfuegenBei(6, 602); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 602, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 602, 790, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + + dieListe.einfuegenBei(6, 397); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 397, 602, 790, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 781); + Tester.pruefeListenInhalt(dieListe, new int[]{781}); + + dieListe.einfuegenBei(0, 964); + Tester.pruefeListenInhalt(dieListe, new int[]{964, 781}); + + dieListe.einfuegenBei(0, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{380, 964, 781}); + + dieListe.einfuegenBei(0, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{991, 380, 964, 781}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{92, 854}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{854}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(24); + Tester.pruefeListenInhalt(dieListe, new int[]{24}); + + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertFalse("Fehler: Element 769 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(769)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 739); + Tester.pruefeListenInhalt(dieListe, new int[]{739}); + + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + dieListe.einfuegenBei(1, 609); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646}); + + assertFalse("Fehler: Element 697 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(697)); + dieListe.anhaengen(611); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646, 611}); + + dieListe.anhaengen(159); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646, 611, 159}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 646, 611, 159}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159}); + + dieListe.einfuegenBei(3, 86); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159, 86}); + + assertTrue("Fehler: Element 159 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(159)); + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159, 86, 535}); + + dieListe.einfuegenBei(2, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535}); + + dieListe.anhaengen(445); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535, 445}); + + assertFalse("Fehler: Element 794 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(794)); + dieListe.anhaengen(153); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535, 445, 153}); + + dieListe.einfuegenBei(1, 866); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 445, 153}); + + dieListe.anhaengen(574); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 445, 153, 574}); + + dieListe.einfuegenBei(7, 169); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707}); + + dieListe.einfuegenBei(0, 911); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707}); + + assertFalse("Fehler: Element 476 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(476)); + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707, 353}); + + dieListe.einfuegenBei(1, 459); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707, 353}); + + dieListe.einfuegenBei(6, 431); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 574, 707, 353}); + + assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672)); + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 707, 353}); + + dieListe.einfuegenBei(0, 87); + Tester.pruefeListenInhalt(dieListe, new int[]{87, 911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 707, 353}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{87, 911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 707, 353}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{83}); + + assertFalse("Fehler: Element 893 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(893)); + dieListe.einfuegenBei(0, 421); + Tester.pruefeListenInhalt(dieListe, new int[]{421, 83}); + + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + dieListe.einfuegenBei(0, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 421, 83}); + + assertFalse("Fehler: Element 736 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(736)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 421}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{421}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 639); + Tester.pruefeListenInhalt(dieListe, new int[]{639}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{311}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{175}); + + assertFalse("Fehler: Element 352 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(352)); + dieListe.anhaengen(759); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 759}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{175}); + + assertTrue("Fehler: Element 175 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(175)); + assertFalse("Fehler: Element 203 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(203)); + assertTrue("Fehler: Element 175 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(175)); + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 117}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 117, 664}); + + dieListe.einfuegenBei(3, 1); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 117, 664, 1}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 661); + Tester.pruefeListenInhalt(dieListe, new int[]{661}); + + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{661, 285}); + + dieListe.einfuegenBei(2, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{661, 285, 234}); + + assertTrue("Fehler: Element 234 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(234)); + dieListe.anhaengen(249); + Tester.pruefeListenInhalt(dieListe, new int[]{661, 285, 234, 249}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 234, 249}); + + assertFalse("Fehler: Element 227 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(227)); + assertFalse("Fehler: Element 735 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(735)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 234}); + + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 234, 769}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 769}); + + dieListe.einfuegenBei(1, 617); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 617, 769}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 617}); + + assertTrue("Fehler: Element 234 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(234)); + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 617, 998}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 998}); + + assertFalse("Fehler: Element 591 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(591)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{998}); + + dieListe.einfuegenBei(1, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976}); + + assertTrue("Fehler: Element 976 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474}); + + assertFalse("Fehler: Element 806 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(806)); + assertTrue("Fehler: Element 976 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(666); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666}); + + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666, 983}); + + dieListe.anhaengen(428); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666, 983, 428}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 666, 983, 428}); + + assertFalse("Fehler: Element 517 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(517)); + dieListe.anhaengen(778); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 666, 983, 428, 778}); + + dieListe.einfuegenBei(2, 424); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 424, 666, 983, 428, 778}); + + assertTrue("Fehler: Element 424 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(424)); + assertFalse("Fehler: Element 891 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(891)); + assertFalse("Fehler: Element 81 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(81)); + dieListe.einfuegenBei(1, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 666, 983, 428, 778}); + + assertFalse("Fehler: Element 809 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(809)); + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 666, 983, 428, 778, 623}); + + dieListe.einfuegenBei(4, 412); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 778, 623}); + + dieListe.anhaengen(321); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 778, 623, 321}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 623, 321}); + + dieListe.einfuegenBei(10, 658); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 623, 321, 658}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 321, 658}); + + assertFalse("Fehler: Element 924 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(924)); + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 321, 658, 719}); + + dieListe.einfuegenBei(8, 367); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 719}); + + dieListe.einfuegenBei(12, 35); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 719, 35}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 35}); + + dieListe.einfuegenBei(7, 973); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35}); + + assertTrue("Fehler: Element 412 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(412)); + dieListe.anhaengen(840); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840}); + + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840, 95}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 35, 840, 95}); + + dieListe.einfuegenBei(7, 499); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 840, 95}); + + assertFalse("Fehler: Element 599 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(599)); + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95}); + + dieListe.anhaengen(448); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95, 448}); + + assertFalse("Fehler: Element 296 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(296)); + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95, 448, 105}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 321, 35, 95, 448, 105}); + + assertFalse("Fehler: Element 903 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(903)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 321, 95, 448, 105}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 95, 448, 105}); + + dieListe.einfuegenBei(12, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 95, 448, 105, 42}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 95, 448, 105, 42}); + + assertFalse("Fehler: Element 317 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(317)); + assertTrue("Fehler: Element 42 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(42)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 448, 105, 42}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 448, 105, 42, 874}); + + assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 623, 448, 105, 42, 874}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 983, 428, 973, 623, 448, 105, 42, 874}); + + dieListe.einfuegenBei(2, 120); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 120, 983, 428, 973, 623, 448, 105, 42, 874}); + + dieListe.einfuegenBei(4, 683); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 120, 983, 683, 428, 973, 623, 448, 105, 42, 874}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{388}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 417); + Tester.pruefeListenInhalt(dieListe, new int[]{417}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85}); + + dieListe.einfuegenBei(0, 3); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 85}); + + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 85, 725}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707}); + + assertFalse("Fehler: Element 523 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(523)); + assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707)); + dieListe.anhaengen(455); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707, 455}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707, 455, 196}); + + assertFalse("Fehler: Element 290 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(290)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 196}); + + dieListe.einfuegenBei(3, 454); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 454, 196}); + + dieListe.anhaengen(489); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 454, 196, 489}); + + assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707)); + assertTrue("Fehler: Element 196 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(196)); + dieListe.einfuegenBei(3, 772); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489}); + + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672}); + + assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368)); + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672)); + dieListe.anhaengen(79); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672, 79}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672, 79, 219}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(354); + Tester.pruefeListenInhalt(dieListe, new int[]{354}); + + dieListe.einfuegenBei(1, 780); + Tester.pruefeListenInhalt(dieListe, new int[]{354, 780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(221); + Tester.pruefeListenInhalt(dieListe, new int[]{221}); + + dieListe.einfuegenBei(0, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{92, 221}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.einfuegenBei(0, 799); + Tester.pruefeListenInhalt(dieListe, new int[]{799, 92}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.einfuegenBei(1, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{92, 588}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(879); + Tester.pruefeListenInhalt(dieListe, new int[]{879}); + + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409}); + + assertFalse("Fehler: Element 982 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(982)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688}); + + dieListe.anhaengen(377); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 377}); + + dieListe.einfuegenBei(3, 763); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 763, 377}); + + assertFalse("Fehler: Element 206 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(206)); + assertFalse("Fehler: Element 461 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(461)); + dieListe.einfuegenBei(4, 306); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 763, 306, 377}); + + dieListe.einfuegenBei(1, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 409, 688, 763, 306, 377}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 306, 377}); + + dieListe.einfuegenBei(4, 148); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377, 675}); + + dieListe.einfuegenBei(7, 893); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377, 893, 675}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 688, 763, 148, 306, 377, 893, 675}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 688, 763, 306, 377, 893, 675}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 377, 893, 675}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 675}); + + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + dieListe.einfuegenBei(4, 97); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675}); + + assertFalse("Fehler: Element 348 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(348)); + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675, 868}); + + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675, 868, 688}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 306, 893, 97, 675, 868, 688}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 692); + Tester.pruefeListenInhalt(dieListe, new int[]{692}); + + dieListe.einfuegenBei(0, 130); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692}); + + dieListe.einfuegenBei(0, 541); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692}); + + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92}); + + dieListe.einfuegenBei(4, 695); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 695}); + + dieListe.einfuegenBei(4, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 157, 695}); + + assertTrue("Fehler: Element 692 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(692)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 695}); + + assertTrue("Fehler: Element 541 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(541)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 695}); + + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 695, 170}); + + dieListe.einfuegenBei(3, 159); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 159, 695, 170}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 159, 170}); + + dieListe.einfuegenBei(1, 7); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 7, 692, 92, 159, 170}); + + assertFalse("Fehler: Element 216 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(216)); + dieListe.einfuegenBei(0, 828); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170}); + + assertFalse("Fehler: Element 913 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(913)); + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526, 634}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526, 634, 576}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 692, 92, 159, 170, 526, 634, 576}); + + dieListe.einfuegenBei(2, 967); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576}); + + dieListe.anhaengen(530); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530}); + + dieListe.anhaengen(612); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 612}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530}); + + dieListe.einfuegenBei(1, 941); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530}); + + assertTrue("Fehler: Element 828 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(828)); + assertTrue("Fehler: Element 941 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(941)); + dieListe.anhaengen(220); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 220}); + + dieListe.anhaengen(11); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 220, 11}); + + assertFalse("Fehler: Element 734 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(734)); + dieListe.einfuegenBei(5, 335); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 335, 92, 159, 170, 526, 634, 576, 530, 220, 11}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 335, 159, 170, 526, 634, 576, 530, 220, 11}); + + assertTrue("Fehler: Element 130 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(130)); + dieListe.einfuegenBei(1, 469); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 469, 941, 130, 967, 692, 335, 159, 170, 526, 634, 576, 530, 220, 11}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 469, 941, 130, 967, 692, 335, 159, 170, 526, 634, 530, 220, 11}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 151); + Tester.pruefeListenInhalt(dieListe, new int[]{151}); + + dieListe.einfuegenBei(0, 709); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 151}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 151, 262}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262}); + + assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262)); + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21, 502}); + + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21, 502, 527}); + + dieListe.anhaengen(850); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21, 502, 527, 850}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 21, 502, 527, 850}); + + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 502, 527, 850}); + + assertFalse("Fehler: Element 584 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(584)); + dieListe.einfuegenBei(0, 364); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850}); + + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 89}); + + dieListe.anhaengen(710); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 89, 710}); + + assertTrue("Fehler: Element 710 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(710)); + dieListe.einfuegenBei(5, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 185, 89, 710}); + + dieListe.einfuegenBei(4, 862); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710}); + + dieListe.anhaengen(24); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24}); + + assertTrue("Fehler: Element 364 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(364)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391}); + + assertTrue("Fehler: Element 850 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(850)); + assertTrue("Fehler: Element 185 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(185)); + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391, 355}); + + dieListe.anhaengen(174); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391, 355, 174}); + + dieListe.einfuegenBei(9, 732); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 174}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 174, 137}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 137}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883}); + + dieListe.einfuegenBei(4, 60); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883}); + + dieListe.anhaengen(140); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140}); + + assertFalse("Fehler: Element 792 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(792)); + dieListe.einfuegenBei(5, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 368, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140}); + + dieListe.einfuegenBei(11, 236); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + assertTrue("Fehler: Element 326 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(326)); + dieListe.einfuegenBei(8, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.einfuegenBei(6, 120); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 326, 883, 140}); + + dieListe.anhaengen(234); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 326, 883, 140, 234}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{931}); + + dieListe.einfuegenBei(0, 103); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 931}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 931, 707}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 931}); + + dieListe.einfuegenBei(0, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 103, 931}); + + dieListe.anhaengen(428); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 103, 931, 428}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 103, 931, 428, 463}); + + dieListe.einfuegenBei(0, 128); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 103, 931, 428, 463}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 103, 931, 428, 463, 689}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689}); + + dieListe.anhaengen(135); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135, 99}); + + dieListe.anhaengen(192); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135, 99, 192}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 135, 99, 192}); + + dieListe.einfuegenBei(7, 905); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 135, 99, 905, 192}); + + dieListe.einfuegenBei(1, 44); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 44, 77, 931, 428, 463, 135, 99, 905, 192}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 99, 905, 192}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 905, 192}); + + assertFalse("Fehler: Element 580 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(580)); + dieListe.einfuegenBei(8, 815); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 905, 192, 815}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 905, 192, 815}); + + dieListe.einfuegenBei(6, 300); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 905, 300, 192, 815}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 905, 300, 192, 815}); + + dieListe.einfuegenBei(1, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815}); + + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672}); + + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575}); + + assertFalse("Fehler: Element 670 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(670)); + dieListe.anhaengen(133); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133, 967}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44)); + assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985)); + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 575, 133}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + dieListe.anhaengen(906); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 575, 133, 906}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + assertFalse("Fehler: Element 793 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(793)); + dieListe.einfuegenBei(5, 789); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906}); + + assertTrue("Fehler: Element 906 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(906)); + dieListe.anhaengen(548); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548}); + + dieListe.anhaengen(471); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548, 471}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + dieListe.einfuegenBei(15, 540); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548, 471, 540}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 815, 575, 133, 906, 548, 471, 540}); + + assertFalse("Fehler: Element 541 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(541)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540}); + + dieListe.anhaengen(999); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999}); + + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999, 382}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999, 382}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{449}); + + assertFalse("Fehler: Element 884 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(884)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(948); + Tester.pruefeListenInhalt(dieListe, new int[]{948}); + + dieListe.einfuegenBei(1, 728); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728}); + + assertTrue("Fehler: Element 948 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(948)); + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890}); + + dieListe.einfuegenBei(3, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382}); + + dieListe.einfuegenBei(4, 168); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168}); + + assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890)); + dieListe.anhaengen(849); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 849}); + + assertTrue("Fehler: Element 948 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(948)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225}); + + dieListe.einfuegenBei(6, 56); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225, 56}); + + dieListe.einfuegenBei(6, 256); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225, 256, 56}); + + dieListe.einfuegenBei(0, 47); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 168, 225, 256, 56}); + + dieListe.einfuegenBei(5, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56}); + + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56, 867}); + + dieListe.anhaengen(497); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497}); + + dieListe.einfuegenBei(8, 780); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497}); + + dieListe.anhaengen(11); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497, 11}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497, 11}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497, 11}); + + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497, 11, 832}); + + dieListe.einfuegenBei(4, 283); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832, 453}); + + dieListe.einfuegenBei(5, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 11, 832, 453}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 453}); + + dieListe.anhaengen(859); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 453, 859}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859}); + + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793}); + + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.einfuegenBei(1, 420); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 392}); + + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(7, 593); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.einfuegenBei(17, 832); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832}); + + assertTrue("Fehler: Element 832 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(832)); + dieListe.einfuegenBei(4, 505); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832}); + + dieListe.einfuegenBei(14, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832}); + + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631}); + + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534}); + + dieListe.einfuegenBei(5, 395); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534, 718}); + + dieListe.anhaengen(144); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534, 718, 144}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(752); + Tester.pruefeListenInhalt(dieListe, new int[]{752}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 885); + Tester.pruefeListenInhalt(dieListe, new int[]{885}); + + assertFalse("Fehler: Element 533 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(533)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{868}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 490}); + + dieListe.einfuegenBei(1, 276); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 276, 490}); + + dieListe.einfuegenBei(2, 339); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 276, 339, 490}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 339, 490}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 339}); + + dieListe.einfuegenBei(2, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 339, 990}); + + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 990}); + + dieListe.einfuegenBei(0, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 990}); + + assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725)); + dieListe.einfuegenBei(2, 738); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 738, 990}); + + assertFalse("Fehler: Element 615 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(615)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 990}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868}); + + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{185}); + + assertTrue("Fehler: Element 185 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(185)); + dieListe.einfuegenBei(0, 622); + Tester.pruefeListenInhalt(dieListe, new int[]{622, 185}); + + assertFalse("Fehler: Element 668 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(668)); + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{622, 185, 637}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{622, 185, 637, 718}); + + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718)); + assertFalse("Fehler: Element 442 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(442)); + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 637, 718}); + + dieListe.einfuegenBei(3, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 637, 718, 92}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 718, 92}); + + assertFalse("Fehler: Element 590 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(590)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 92}); + + dieListe.anhaengen(597); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 92, 597}); + + dieListe.einfuegenBei(1, 401); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 401, 92, 597}); + + dieListe.einfuegenBei(3, 937); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 401, 92, 937, 597}); + + dieListe.einfuegenBei(0, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 401, 92, 937, 597}); + + assertTrue("Fehler: Element 597 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(597)); + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 401, 92, 937, 597, 251}); + + dieListe.einfuegenBei(2, 492); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251, 704}); + + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + assertFalse("Fehler: Element 681 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(681)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{799}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{799, 137}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{799}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{262}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 403}); + + dieListe.einfuegenBei(2, 118); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 403, 118}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118}); + + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905}); + + dieListe.einfuegenBei(3, 135); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135}); + + assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135, 391}); + + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135, 391, 452}); + + assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 905, 135, 391, 452}); + + dieListe.anhaengen(508); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 905, 135, 391, 452, 508}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 135, 391, 452, 508}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 391, 452, 508}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + dieListe.einfuegenBei(3, 68); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 391, 452, 68, 508}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{108}); + + dieListe.einfuegenBei(1, 989); + Tester.pruefeListenInhalt(dieListe, new int[]{108, 989}); + + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(912); + Tester.pruefeListenInhalt(dieListe, new int[]{108, 989, 912}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(81); + Tester.pruefeListenInhalt(dieListe, new int[]{81}); + + dieListe.anhaengen(928); + Tester.pruefeListenInhalt(dieListe, new int[]{81, 928}); + + assertFalse("Fehler: Element 400 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(400)); + assertFalse("Fehler: Element 600 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(600)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{81}); + + dieListe.einfuegenBei(0, 700); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81}); + + dieListe.anhaengen(991); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81, 991}); + + assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81}); + + dieListe.einfuegenBei(2, 292); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81, 292}); + + dieListe.einfuegenBei(1, 379); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 634}); + + dieListe.einfuegenBei(5, 319); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 634, 319}); + + assertTrue("Fehler: Element 700 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(700)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 319}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292}); + + dieListe.anhaengen(4); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4}); + + dieListe.anhaengen(274); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4, 274}); + + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + assertTrue("Fehler: Element 4 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(4)); + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4, 274, 822}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 292, 4, 274, 822}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 4, 274, 822}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 4, 822}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 822}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292}); + + assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{292}); + + dieListe.einfuegenBei(1, 203); + Tester.pruefeListenInhalt(dieListe, new int[]{292, 203}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); + dieListe.einfuegenBei(0, 366); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 292, 203}); + + dieListe.anhaengen(400); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 292, 203, 400}); + + assertTrue("Fehler: Element 400 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(400)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 203, 400}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 400}); + + dieListe.einfuegenBei(0, 963); + Tester.pruefeListenInhalt(dieListe, new int[]{963, 366, 400}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 400}); + + dieListe.einfuegenBei(0, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 400}); + + dieListe.einfuegenBei(3, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 400, 813}); + + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 400, 813, 881}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 813, 881}); + + dieListe.anhaengen(172); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 813, 881, 172}); + + dieListe.einfuegenBei(1, 509); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 366, 813, 881, 172}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.einfuegenBei(6, 355); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 366, 813, 881, 172, 355}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 813, 881, 172, 355}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 813, 881, 172, 355, 247}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 881, 172, 355, 247}); + + dieListe.einfuegenBei(1, 543); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 881, 172, 355, 247}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 172, 355, 247}); + + dieListe.einfuegenBei(6, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 172, 355, 247, 59}); + + assertFalse("Fehler: Element 705 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(705)); + dieListe.einfuegenBei(0, 334); + Tester.pruefeListenInhalt(dieListe, new int[]{334, 778, 543, 509, 172, 355, 247, 59}); + + dieListe.einfuegenBei(0, 137); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 509, 172, 355, 247, 59}); + + dieListe.einfuegenBei(8, 339); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 509, 172, 355, 247, 339, 59}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 172, 355, 247, 339, 59}); + + dieListe.einfuegenBei(4, 754); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59}); + + dieListe.anhaengen(61); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59, 61}); + + dieListe.anhaengen(447); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59, 61, 447}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 339, 59, 61, 447}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 754, 172, 355, 339, 59, 61, 447}); + + assertFalse("Fehler: Element 138 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(138)); + dieListe.einfuegenBei(2, 18); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 61, 447}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 447}); + + dieListe.einfuegenBei(7, 355); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 355, 339, 59, 447}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 447}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 355, 339, 59, 447}); + + dieListe.einfuegenBei(1, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 778, 754, 355, 339, 59, 447}); + + dieListe.einfuegenBei(4, 343); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 447}); + + dieListe.einfuegenBei(10, 268); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 268, 447}); + + dieListe.einfuegenBei(10, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447}); + + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447, 968}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447, 968, 186}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest8.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest8.java new file mode 100644 index 0000000..d8dc5a3 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest8.java @@ -0,0 +1,2821 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest8. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest8 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(801); + Tester.pruefeListenInhalt(dieListe, new int[]{801}); + + dieListe.einfuegenBei(0, 658); + Tester.pruefeListenInhalt(dieListe, new int[]{658, 801}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{658, 801, 896}); + + dieListe.einfuegenBei(0, 618); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 658, 801, 896}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 658, 801}); + + assertTrue("Fehler: Element 658 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(658)); + dieListe.einfuegenBei(1, 715); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658, 801}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658}); + + dieListe.anhaengen(888); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658, 888}); + + dieListe.einfuegenBei(0, 224); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 658, 888}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 888}); + + dieListe.einfuegenBei(3, 550); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 550, 888}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 550}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 715, 550}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{715, 550}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{715}); + + dieListe.einfuegenBei(0, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715}); + + dieListe.anhaengen(687); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687}); + + dieListe.anhaengen(939); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967}); + + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40}); + + assertFalse("Fehler: Element 879 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(879)); + dieListe.einfuegenBei(6, 55); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40, 55}); + + dieListe.anhaengen(80); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40, 55, 80}); + + assertTrue("Fehler: Element 939 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(939)); + dieListe.einfuegenBei(4, 357); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 357, 967, 40, 55, 80}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 357, 967, 40, 55, 80, 245}); + + assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 55, 80, 245}); + + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 55, 80, 245, 395}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 80, 245, 395}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 80, 245, 395, 437}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 437}); + + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 437, 494}); + + assertFalse("Fehler: Element 762 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(762)); + dieListe.einfuegenBei(8, 282); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 282, 437, 494}); + + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertFalse("Fehler: Element 855 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(855)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 282, 437}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.einfuegenBei(8, 123); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437}); + + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82, 437}); + + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82, 437, 77}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + dieListe.einfuegenBei(6, 155); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77, 570}); + + assertFalse("Fehler: Element 456 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(456)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77, 570}); + + assertFalse("Fehler: Element 379 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(379)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + dieListe.einfuegenBei(11, 585); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 82, 437, 77, 570}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 82, 437, 77}); + + assertFalse("Fehler: Element 560 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(560)); + dieListe.einfuegenBei(12, 53); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.einfuegenBei(0, 512); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + assertTrue("Fehler: Element 715 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(715)); + dieListe.einfuegenBei(1, 142); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 142, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853}); + + assertTrue("Fehler: Element 437 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853, 797}); + + assertTrue("Fehler: Element 877 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(877)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853, 797}); + + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797}); + + dieListe.anhaengen(405); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405}); + + dieListe.einfuegenBei(3, 454); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405}); + + dieListe.anhaengen(642); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642}); + + dieListe.anhaengen(438); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642, 438}); + + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 405, 642, 438}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 405, 642}); + + dieListe.einfuegenBei(15, 425); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642}); + + assertFalse("Fehler: Element 61 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(61)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642}); + + dieListe.einfuegenBei(15, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22}); + + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22, 25}); + + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + assertTrue("Fehler: Element 405 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(405)); + dieListe.anhaengen(591); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + dieListe.einfuegenBei(0, 181); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145}); + + dieListe.einfuegenBei(6, 117); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 117, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145}); + + dieListe.einfuegenBei(6, 495); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 495, 117, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145}); + + dieListe.einfuegenBei(15, 918); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 495, 117, 437, 585, 53, 82, 877, 797, 425, 918, 405, 75, 642, 22, 25, 591, 145}); + + assertFalse("Fehler: Element 39 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(39)); + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{449}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(136); + Tester.pruefeListenInhalt(dieListe, new int[]{136}); + + assertTrue("Fehler: Element 136 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(136)); + dieListe.einfuegenBei(0, 783); + Tester.pruefeListenInhalt(dieListe, new int[]{783, 136}); + + dieListe.anhaengen(630); + Tester.pruefeListenInhalt(dieListe, new int[]{783, 136, 630}); + + assertTrue("Fehler: Element 783 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(783)); + dieListe.einfuegenBei(2, 107); + Tester.pruefeListenInhalt(dieListe, new int[]{783, 136, 107, 630}); + + assertFalse("Fehler: Element 697 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(697)); + dieListe.einfuegenBei(0, 986); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 783, 136, 107, 630}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 783, 136, 107, 630, 441}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 136, 107, 630, 441}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 136, 107, 441}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 107, 441}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 107, 441}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 107, 441, 758}); + + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.einfuegenBei(1, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758}); + + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758, 19}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758, 19, 465}); + + dieListe.einfuegenBei(3, 602); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 602, 107, 441, 758, 19, 465}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 602, 107, 441, 758, 465}); + + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 623); + Tester.pruefeListenInhalt(dieListe, new int[]{623}); + + assertFalse("Fehler: Element 98 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(98)); + dieListe.einfuegenBei(0, 96); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 623}); + + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.einfuegenBei(2, 146); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 623, 146}); + + dieListe.einfuegenBei(3, 268); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 623, 146, 268}); + + dieListe.einfuegenBei(1, 195); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 623, 146, 268}); + + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 146, 268}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 146}); + + dieListe.einfuegenBei(2, 115); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 115, 146}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146}); + + dieListe.einfuegenBei(3, 850); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146, 850}); + + assertFalse("Fehler: Element 944 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(944)); + dieListe.einfuegenBei(4, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146, 850, 532}); + + dieListe.einfuegenBei(1, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532}); + + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532, 6}); + + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532, 6, 631}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 631}); + + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 631, 257}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 257}); + + assertFalse("Fehler: Element 833 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(833)); + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.einfuegenBei(3, 655); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257}); + + dieListe.anhaengen(358); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257, 358}); + + assertFalse("Fehler: Element 249 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(249)); + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257, 358, 154}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 584); + Tester.pruefeListenInhalt(dieListe, new int[]{584}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{557}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 520); + Tester.pruefeListenInhalt(dieListe, new int[]{520}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{26}); + + assertTrue("Fehler: Element 26 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(26)); + dieListe.einfuegenBei(0, 791); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26}); + + dieListe.einfuegenBei(2, 198); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198}); + + assertFalse("Fehler: Element 29 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(29)); + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + dieListe.einfuegenBei(1, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 78, 26, 198}); + + dieListe.anhaengen(925); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 78, 26, 198, 925}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 925}); + + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 925, 568}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 568}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568}); + + dieListe.einfuegenBei(3, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568, 436}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568, 436, 137}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 623); + Tester.pruefeListenInhalt(dieListe, new int[]{623}); + + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 731}); + + dieListe.einfuegenBei(1, 808); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731, 329}); + + dieListe.anhaengen(33); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731, 329, 33}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620}); + + dieListe.einfuegenBei(0, 425); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 623, 808, 329, 33, 620}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 623, 808, 329, 33, 620, 718}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 718}); + + dieListe.anhaengen(951); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 718, 951}); + + dieListe.einfuegenBei(5, 928); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 928, 718, 951}); + + assertFalse("Fehler: Element 390 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(390)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{808, 329, 33, 620, 928, 718, 951}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 620, 928, 718, 951}); + + dieListe.einfuegenBei(2, 897); + Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 897, 620, 928, 718, 951}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 897, 620, 718, 951}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{414}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521}); + + dieListe.anhaengen(63); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63}); + + assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265)); + dieListe.einfuegenBei(1, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63}); + + dieListe.anhaengen(724); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724}); + + assertFalse("Fehler: Element 316 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(316)); + dieListe.einfuegenBei(5, 890); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724, 890}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63, 724}); + + assertTrue("Fehler: Element 724 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(724)); + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63, 724, 157}); + + assertTrue("Fehler: Element 521 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(521)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 63, 724, 157}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 724, 157}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 157}); + + dieListe.einfuegenBei(0, 533); + Tester.pruefeListenInhalt(dieListe, new int[]{533, 63, 157}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 157}); + + dieListe.einfuegenBei(2, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 157, 647}); + + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647}); + + dieListe.anhaengen(386); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647, 386}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647}); + + dieListe.einfuegenBei(2, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647, 247}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 629); + Tester.pruefeListenInhalt(dieListe, new int[]{629}); + + dieListe.einfuegenBei(1, 5); + Tester.pruefeListenInhalt(dieListe, new int[]{629, 5}); + + dieListe.einfuegenBei(2, 290); + Tester.pruefeListenInhalt(dieListe, new int[]{629, 5, 290}); + + dieListe.einfuegenBei(1, 167); + Tester.pruefeListenInhalt(dieListe, new int[]{629, 167, 5, 290}); + + assertTrue("Fehler: Element 629 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(629)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{167, 5, 290}); + + assertTrue("Fehler: Element 167 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(167)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{167, 290}); + + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + assertFalse("Fehler: Element 762 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(762)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{290}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{748}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{967}); + + assertTrue("Fehler: Element 967 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(967)); + dieListe.einfuegenBei(1, 797); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797}); + + dieListe.anhaengen(445); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + assertFalse("Fehler: Element 708 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(708)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445, 328}); + + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445, 328, 434}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 434}); + + dieListe.einfuegenBei(3, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 434}); + + assertTrue("Fehler: Element 434 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(434)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183}); + + dieListe.einfuegenBei(2, 154); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 154, 328, 183}); + + dieListe.einfuegenBei(1, 361); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 361, 797, 154, 328, 183}); + + dieListe.anhaengen(171); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 361, 797, 154, 328, 183, 171}); + + dieListe.einfuegenBei(1, 153); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 154, 328, 183, 171}); + + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + assertTrue("Fehler: Element 967 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(967)); + dieListe.einfuegenBei(0, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{842, 967, 153, 361, 797, 154, 328, 183, 171}); + + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{842, 967, 153, 361, 797, 154, 328, 183, 171, 86}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 154, 328, 183, 171, 86}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 86}); + + dieListe.anhaengen(745); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 86, 745}); + + assertFalse("Fehler: Element 283 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(283)); + dieListe.einfuegenBei(7, 945); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 945, 86, 745}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 797, 328, 183, 171, 945, 86, 745}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 171, 945, 86, 745}); + + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745)); + dieListe.einfuegenBei(5, 926); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 171, 926, 945, 86, 745}); + + dieListe.einfuegenBei(0, 374); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 797, 328, 183, 171, 926, 945, 86, 745}); + + dieListe.einfuegenBei(7, 68); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 797, 328, 183, 171, 926, 68, 945, 86, 745}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 328, 183, 171, 926, 68, 945, 86, 745}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 183, 171, 926, 68, 945, 86, 745}); + + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); + assertTrue("Fehler: Element 86 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 378 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(378)); + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 183, 171, 926, 68, 945, 86, 745, 71}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 86, 745, 71}); + + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 86, 745, 71, 615}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 745, 71, 615}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 945, 745, 71, 615}); + + dieListe.einfuegenBei(2, 529); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 926 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(926)); + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335}); + + assertTrue("Fehler: Element 945 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(945)); + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857}); + + dieListe.anhaengen(784); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784}); + + dieListe.anhaengen(248); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784, 248}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784}); + + assertTrue("Fehler: Element 857 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(857)); + dieListe.anhaengen(717); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784, 717}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 784, 717}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 529, 171, 926, 945, 745, 71, 615, 335, 784, 717}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{481}); + + dieListe.einfuegenBei(0, 263); + Tester.pruefeListenInhalt(dieListe, new int[]{263, 481}); + + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 263, 481}); + + dieListe.einfuegenBei(0, 424); + Tester.pruefeListenInhalt(dieListe, new int[]{424, 85, 263, 481}); + + dieListe.einfuegenBei(0, 565); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 85, 263, 481}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481}); + + dieListe.einfuegenBei(4, 272); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481, 272}); + + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481, 272, 3}); + + dieListe.einfuegenBei(3, 803); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 803, 481, 272, 3}); + + dieListe.einfuegenBei(2, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 263, 803, 481, 272, 3}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 803, 481, 272, 3}); + + dieListe.anhaengen(658); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 803, 481, 272, 3, 658}); + + dieListe.einfuegenBei(0, 893); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 980, 803, 481, 272, 3, 658}); + + dieListe.anhaengen(572); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 980, 803, 481, 272, 3, 658, 572}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 803, 481, 272, 3, 658, 572}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 803, 481, 272, 3, 658, 572}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 803, 481, 272, 3, 658}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{388}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(204); + Tester.pruefeListenInhalt(dieListe, new int[]{204}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935}); + + assertFalse("Fehler: Element 524 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(524)); + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19}); + + dieListe.anhaengen(458); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19, 458}); + + dieListe.anhaengen(379); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19, 458, 379}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{935, 19, 458, 379}); + + assertTrue("Fehler: Element 935 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(935)); + dieListe.einfuegenBei(0, 127); + Tester.pruefeListenInhalt(dieListe, new int[]{127, 935, 19, 458, 379}); + + assertTrue("Fehler: Element 935 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(935)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 828); + Tester.pruefeListenInhalt(dieListe, new int[]{828}); + + dieListe.einfuegenBei(1, 714); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714}); + + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 863}); + + dieListe.einfuegenBei(2, 333); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 333, 863}); + + dieListe.einfuegenBei(0, 203); + Tester.pruefeListenInhalt(dieListe, new int[]{203, 828, 714, 333, 863}); + + dieListe.anhaengen(266); + Tester.pruefeListenInhalt(dieListe, new int[]{203, 828, 714, 333, 863, 266}); + + assertTrue("Fehler: Element 203 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(203)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 333, 863, 266}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 333, 863, 266}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 333, 266}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 333}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 876); + Tester.pruefeListenInhalt(dieListe, new int[]{876}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{484}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 24); + Tester.pruefeListenInhalt(dieListe, new int[]{24}); + + dieListe.einfuegenBei(1, 810); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + dieListe.einfuegenBei(1, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810}); + + assertFalse("Fehler: Element 727 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(727)); + dieListe.anhaengen(693); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693}); + + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693, 340}); + + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693, 340, 86}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 86}); + + dieListe.anhaengen(796); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 86, 796}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 796}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.einfuegenBei(5, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 796, 218}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 218}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 340, 218}); + + assertFalse("Fehler: Element 732 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(732)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 340, 218}); + + dieListe.einfuegenBei(0, 395); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 24, 340, 218}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 24, 218}); + + dieListe.einfuegenBei(0, 279); + Tester.pruefeListenInhalt(dieListe, new int[]{279, 395, 24, 218}); + + dieListe.einfuegenBei(0, 604); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 279, 395, 24, 218}); + + dieListe.einfuegenBei(4, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 279, 395, 24, 798, 218}); + + assertFalse("Fehler: Element 836 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(836)); + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 279, 395, 24, 798, 218}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798, 218}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798, 217}); + + assertFalse("Fehler: Element 597 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(597)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 217}); + + assertTrue("Fehler: Element 85 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(85)); + assertFalse("Fehler: Element 16 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(16)); + dieListe.einfuegenBei(3, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 553, 24, 217}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 553, 24, 217}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217}); + + dieListe.anhaengen(429); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429}); + + dieListe.anhaengen(956); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956}); + + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956, 334}); + + assertTrue("Fehler: Element 334 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(334)); + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956, 334, 461}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 334, 461}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461}); + + dieListe.anhaengen(635); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461, 635}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461, 635, 718}); + + assertTrue("Fehler: Element 461 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(461)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 334, 461, 635, 718}); + + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 334, 461, 635, 718, 651}); + + dieListe.einfuegenBei(1, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 651}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 651, 108}); + + dieListe.einfuegenBei(8, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 568, 651, 108}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 718, 568, 651, 108}); + + dieListe.anhaengen(563); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 718, 568, 651, 108, 563}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 568, 651, 108, 563}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{665}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{665, 262}); + + dieListe.einfuegenBei(0, 41); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 262}); + + dieListe.einfuegenBei(2, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 78, 262}); + + dieListe.einfuegenBei(0, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262}); + + assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262, 340}); + + dieListe.einfuegenBei(5, 648); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262, 648, 340}); + + dieListe.einfuegenBei(3, 421); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 78, 262, 648, 340}); + + dieListe.einfuegenBei(4, 829); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 829, 78, 262, 648, 340}); + + dieListe.einfuegenBei(5, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 829, 757, 78, 262, 648, 340}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 421, 829, 757, 78, 262, 648, 340}); + + assertTrue("Fehler: Element 829 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(829)); + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 421, 829, 757, 78, 262, 648, 340, 870}); + + dieListe.einfuegenBei(0, 720); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 262, 648, 340, 870}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870}); + + dieListe.einfuegenBei(10, 995); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995}); + + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736}); + + assertTrue("Fehler: Element 648 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(648)); + dieListe.anhaengen(119); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119}); + + assertTrue("Fehler: Element 41 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(41)); + dieListe.anhaengen(291); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 291}); + + assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394)); + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 291, 196}); + + assertTrue("Fehler: Element 119 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(119)); + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 196}); + + dieListe.anhaengen(135); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.einfuegenBei(7, 712); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.einfuegenBei(12, 137); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 137, 736, 119, 196, 135}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.einfuegenBei(4, 867); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 421, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.einfuegenBei(5, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 757, 78, 712, 648, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 870, 995, 736, 119, 135, 335}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335}); + + dieListe.einfuegenBei(13, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42}); + + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42, 461}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42, 461}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + dieListe.anhaengen(408); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408}); + + dieListe.einfuegenBei(3, 984); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 736, 119, 135, 335, 42, 461, 408}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + assertTrue("Fehler: Element 984 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(984)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 135, 335, 42, 461, 408}); + + assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(7, 790); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 790, 135, 335, 42, 461, 408}); + + assertFalse("Fehler: Element 131 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(131)); + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 790, 135, 335, 42, 461}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 896); + Tester.pruefeListenInhalt(dieListe, new int[]{896}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{146}); + + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(380); + Tester.pruefeListenInhalt(dieListe, new int[]{146, 380}); + + assertFalse("Fehler: Element 852 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(852)); + dieListe.einfuegenBei(0, 510); + Tester.pruefeListenInhalt(dieListe, new int[]{510, 146, 380}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{510, 146}); + + dieListe.einfuegenBei(2, 535); + Tester.pruefeListenInhalt(dieListe, new int[]{510, 146, 535}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(826); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{826, 923}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{702}); + + dieListe.einfuegenBei(0, 754); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539}); + + dieListe.einfuegenBei(0, 638); + Tester.pruefeListenInhalt(dieListe, new int[]{638, 754, 702, 539}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539}); + + assertTrue("Fehler: Element 702 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(702)); + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 411}); + + dieListe.einfuegenBei(3, 911); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 911, 411}); + + dieListe.einfuegenBei(5, 138); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 911, 411, 138}); + + dieListe.einfuegenBei(1, 485); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 485, 702, 539, 911, 411, 138}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{869}); + + dieListe.einfuegenBei(0, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{281, 869}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{869}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{436}); + + assertTrue("Fehler: Element 436 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(436)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 938); + Tester.pruefeListenInhalt(dieListe, new int[]{938}); + + dieListe.einfuegenBei(1, 397); + Tester.pruefeListenInhalt(dieListe, new int[]{938, 397}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{397}); + + assertFalse("Fehler: Element 274 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(274)); + dieListe.einfuegenBei(0, 502); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 397}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 397, 315}); + + assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140)); + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 397, 315, 383}); + + assertTrue("Fehler: Element 315 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(315)); + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(429); + Tester.pruefeListenInhalt(dieListe, new int[]{429}); + + dieListe.einfuegenBei(1, 324); + Tester.pruefeListenInhalt(dieListe, new int[]{429, 324}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.einfuegenBei(2, 840); + Tester.pruefeListenInhalt(dieListe, new int[]{429, 324, 840}); + + dieListe.einfuegenBei(0, 173); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840}); + + assertTrue("Fehler: Element 840 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(840)); + assertFalse("Fehler: Element 984 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(984)); + assertFalse("Fehler: Element 641 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(641)); + assertTrue("Fehler: Element 324 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(324)); + dieListe.einfuegenBei(4, 457); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840, 457}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840}); + + dieListe.einfuegenBei(4, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840, 95}); + + assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95}); + + assertFalse("Fehler: Element 669 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(669)); + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95, 708}); + + dieListe.einfuegenBei(4, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95, 707, 708}); + + dieListe.einfuegenBei(3, 33); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95, 707, 708}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95, 708}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95}); + + dieListe.einfuegenBei(2, 128); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 128, 840, 33, 95}); + + dieListe.einfuegenBei(1, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 429, 128, 840, 33, 95}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95, 154}); + + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95, 154, 640}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 154, 640}); + + assertTrue("Fehler: Element 128 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(128)); + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(738); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 154, 640, 738}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738}); + + dieListe.einfuegenBei(7, 637); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637}); + + dieListe.einfuegenBei(8, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637, 532}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637}); + + assertFalse("Fehler: Element 511 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(511)); + dieListe.einfuegenBei(7, 742); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 742, 637}); + + dieListe.einfuegenBei(4, 500); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637, 392}); + + dieListe.anhaengen(550); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637, 392, 550}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(426); + Tester.pruefeListenInhalt(dieListe, new int[]{426}); + + dieListe.einfuegenBei(1, 255); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 255}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{426}); + + dieListe.anhaengen(149); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 387}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149}); + + dieListe.einfuegenBei(2, 716); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 716}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 446}); + + dieListe.einfuegenBei(0, 349); + Tester.pruefeListenInhalt(dieListe, new int[]{349, 426, 149, 446}); + + dieListe.einfuegenBei(3, 271); + Tester.pruefeListenInhalt(dieListe, new int[]{349, 426, 149, 271, 446}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 271, 446}); + + dieListe.einfuegenBei(0, 838); + Tester.pruefeListenInhalt(dieListe, new int[]{838, 426, 149, 271, 446}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{838, 149, 271, 446}); + + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 271, 446}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 271}); + + dieListe.einfuegenBei(1, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 271}); + + dieListe.einfuegenBei(2, 921); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 271}); + + dieListe.einfuegenBei(1, 488); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 488, 496, 921, 271}); + + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 488, 496, 921, 271, 871}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 271, 871}); + + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 871}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 921, 871}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 921, 871, 105}); + + dieListe.einfuegenBei(0, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 149, 921, 871, 105}); + + dieListe.einfuegenBei(0, 733); + Tester.pruefeListenInhalt(dieListe, new int[]{733, 588, 149, 921, 871, 105}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 149, 921, 871, 105}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 921, 871, 105}); + + dieListe.einfuegenBei(0, 971); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 921, 871, 105}); + + dieListe.einfuegenBei(2, 738); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 738, 921, 871, 105}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 921, 871, 105}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 921, 871, 105}); + + dieListe.einfuegenBei(0, 959); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 921, 871, 105}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 105}); + + dieListe.einfuegenBei(3, 313); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 313, 105}); + + dieListe.einfuegenBei(3, 611); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 105}); + + dieListe.einfuegenBei(5, 970); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 970, 105}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 105}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313}); + + dieListe.anhaengen(628); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 628}); + + dieListe.einfuegenBei(0, 214); + Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313, 628}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313, 860}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 860}); + + dieListe.einfuegenBei(3, 508); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 508, 611, 313, 860}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 508, 611, 313, 860}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 508, 611, 313, 860, 446}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 860, 446}); + + dieListe.einfuegenBei(6, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 860, 446, 546}); + + dieListe.einfuegenBei(4, 44); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546}); + + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + dieListe.anhaengen(120); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546, 120}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546, 120, 43}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(555); + Tester.pruefeListenInhalt(dieListe, new int[]{555}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{555, 450}); + + assertTrue("Fehler: Element 450 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(450)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{608}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{409}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{884}); + + dieListe.anhaengen(559); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329}); + + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329, 65}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329}); + + dieListe.einfuegenBei(2, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 218, 329}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329}); + + assertFalse("Fehler: Element 326 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(326)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{559}); + + dieListe.einfuegenBei(0, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 559}); + + assertTrue("Fehler: Element 651 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(651)); + dieListe.anhaengen(399); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 559, 399}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{559, 399}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{757}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{105}); + + dieListe.einfuegenBei(0, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 105}); + + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 105, 121}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 105}); + + dieListe.einfuegenBei(1, 245); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 105}); + + dieListe.anhaengen(950); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 105, 950}); + + dieListe.anhaengen(161); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 105, 950, 161}); + + assertFalse("Fehler: Element 130 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(130)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 950, 161}); + + dieListe.einfuegenBei(1, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 562, 245, 950, 161}); + + dieListe.einfuegenBei(0, 352); + Tester.pruefeListenInhalt(dieListe, new int[]{352, 16, 562, 245, 950, 161}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertFalse("Fehler: Element 466 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(466)); + assertTrue("Fehler: Element 245 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(245)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{77}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 312}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{77}); + + assertFalse("Fehler: Element 940 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(940)); + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + dieListe.einfuegenBei(1, 806); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 806}); + + dieListe.einfuegenBei(2, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 806, 398}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285}); + + dieListe.anhaengen(565); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 565}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285}); + + assertFalse("Fehler: Element 446 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(446)); + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 297}); + + assertTrue("Fehler: Element 806 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(806)); + assertFalse("Fehler: Element 328 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(328)); + dieListe.anhaengen(171); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 297, 171}); + + dieListe.einfuegenBei(0, 39); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 285, 297, 171}); + + dieListe.einfuegenBei(3, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 285, 297, 171}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675}); + + assertFalse("Fehler: Element 301 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(301)); + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 871}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675}); + + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351}); + + dieListe.einfuegenBei(9, 773); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351, 773}); + + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351, 773, 780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 77, 297, 171, 675, 474, 351, 773, 780}); + + dieListe.einfuegenBei(2, 353); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780, 152}); + + assertFalse("Fehler: Element 824 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(824)); + dieListe.einfuegenBei(1, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780, 152}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 152}); + + dieListe.einfuegenBei(11, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152}); + + dieListe.anhaengen(879); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152, 879}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152, 879, 526}); + + dieListe.einfuegenBei(6, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526}); + + dieListe.anhaengen(586); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526, 586}); + + dieListe.anhaengen(919); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526, 586, 919}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 773, 780, 82, 152, 879, 526, 586, 919}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(602); + Tester.pruefeListenInhalt(dieListe, new int[]{602}); + + dieListe.einfuegenBei(0, 135); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 602}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + assertTrue("Fehler: Element 602 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(602)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{135}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 43); + Tester.pruefeListenInhalt(dieListe, new int[]{43}); + + assertTrue("Fehler: Element 43 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(43)); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{43, 440}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{440}); + + dieListe.einfuegenBei(1, 512); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 512}); + + dieListe.einfuegenBei(0, 483); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 440, 512}); + + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + dieListe.anhaengen(80); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 440, 512, 80}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 512, 80}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 512}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{512}); + + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(796); + Tester.pruefeListenInhalt(dieListe, new int[]{796}); + + dieListe.anhaengen(55); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 55}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{796}); + + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 499}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{499}); + + assertTrue("Fehler: Element 499 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(499)); + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263}); + + assertTrue("Fehler: Element 263 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(263)); + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263, 539}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + assertFalse("Fehler: Element 722 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(722)); + assertTrue("Fehler: Element 539 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(539)); + assertTrue("Fehler: Element 499 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(499)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263}); + + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263, 368}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263}); + + dieListe.einfuegenBei(1, 166); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 166, 263}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{686}); + + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998}); + + dieListe.einfuegenBei(0, 506); + Tester.pruefeListenInhalt(dieListe, new int[]{506, 686, 998}); + + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{506, 686, 998, 562}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 562}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 562, 57}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 57}); + + assertFalse("Fehler: Element 22 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(22)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998}); + + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 7}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998}); + + dieListe.anhaengen(994); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 994}); + + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 994, 699}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 699}); + + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 699, 653}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 699, 653}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 653}); + + assertFalse("Fehler: Element 740 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(740)); + dieListe.einfuegenBei(0, 307); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653}); + + dieListe.einfuegenBei(3, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633}); + + dieListe.anhaengen(163); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633, 163}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633}); + + dieListe.einfuegenBei(3, 695); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 695, 633}); + + assertTrue("Fehler: Element 653 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(653)); + assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358)); + dieListe.einfuegenBei(2, 985); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633}); + + dieListe.anhaengen(243); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243}); + + dieListe.anhaengen(912); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243, 912}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243, 912, 923}); + + dieListe.einfuegenBei(2, 527); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 653, 695, 633, 243, 912, 923}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 653, 695, 633, 243, 912, 923, 305}); + + dieListe.einfuegenBei(4, 364); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 364, 653, 695, 633, 243, 912, 923, 305}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305, 110}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305, 110, 896}); + + dieListe.einfuegenBei(8, 554); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896}); + + assertTrue("Fehler: Element 110 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(110)); + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896, 615}); + + dieListe.einfuegenBei(14, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896, 220, 615}); + + dieListe.einfuegenBei(9, 537); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615}); + + dieListe.anhaengen(360); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360}); + + dieListe.einfuegenBei(18, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360, 447}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360, 447, 326}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + dieListe.einfuegenBei(17, 17); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 17, 360, 447, 326}); + + assertTrue("Fehler: Element 985 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(985)); + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593}); + + dieListe.einfuegenBei(0, 716); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679}); + + dieListe.einfuegenBei(2, 243); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 243, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679}); + + dieListe.anhaengen(84); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 243, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679, 84}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + + dieListe.einfuegenBei(0, 364); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 70}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + + dieListe.einfuegenBei(1, 998); + Tester.pruefeListenInhalt(dieListe, new int[]{70, 998}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(143); + Tester.pruefeListenInhalt(dieListe, new int[]{143}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 468); + Tester.pruefeListenInhalt(dieListe, new int[]{468}); + + dieListe.anhaengen(565); + Tester.pruefeListenInhalt(dieListe, new int[]{468, 565}); + + dieListe.einfuegenBei(2, 740); + Tester.pruefeListenInhalt(dieListe, new int[]{468, 565, 740}); + + assertTrue("Fehler: Element 740 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(740)); + assertFalse("Fehler: Element 951 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(951)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 740}); + + assertTrue("Fehler: Element 565 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(565)); + assertFalse("Fehler: Element 793 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(793)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{565}); + + dieListe.einfuegenBei(1, 477); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 477}); + + assertFalse("Fehler: Element 117 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(117)); + assertTrue("Fehler: Element 477 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(477)); + dieListe.einfuegenBei(2, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 477, 666}); + + dieListe.einfuegenBei(0, 255); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 666}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477}); + + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965}); + + dieListe.anhaengen(503); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965, 503}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertTrue("Fehler: Element 965 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(965)); + dieListe.einfuegenBei(5, 614); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965, 503, 614}); + + dieListe.einfuegenBei(3, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 105, 965, 503, 614}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(435); + Tester.pruefeListenInhalt(dieListe, new int[]{435}); + + dieListe.einfuegenBei(1, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{435, 445}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.anhaengen(728); + Tester.pruefeListenInhalt(dieListe, new int[]{435, 445, 728}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{435, 445, 728, 47}); + + dieListe.einfuegenBei(0, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47}); + + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191}); + + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191, 774}); + + dieListe.anhaengen(779); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191, 774, 779}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779}); + + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838}); + + dieListe.anhaengen(223); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 223}); + + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 223, 96}); + + dieListe.einfuegenBei(8, 159); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 159, 223, 96}); + + dieListe.anhaengen(815); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 159, 223, 96, 815}); + + dieListe.einfuegenBei(7, 816); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 96, 815}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 815}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 815, 305}); + + assertFalse("Fehler: Element 300 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(300)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 816, 838, 159, 223, 815, 305}); + + assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 816, 838, 159, 223, 815, 305, 932}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 816, 838, 159, 223, 815, 305, 932}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932}); + + dieListe.anhaengen(396); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351, 267}); + + dieListe.anhaengen(722); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351, 267, 722}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 396, 351, 267, 722}); + + dieListe.einfuegenBei(9, 129); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722}); + + assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267)); + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743}); + + dieListe.anhaengen(737); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 737}); + + dieListe.anhaengen(579); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 737, 579}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 579}); + + assertTrue("Fehler: Element 815 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(815)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(993); + Tester.pruefeListenInhalt(dieListe, new int[]{993}); + + assertFalse("Fehler: Element 89 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(89)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{604}); + + dieListe.anhaengen(228); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 228}); + + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 228, 344}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 344}); + + assertFalse("Fehler: Element 380 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(380)); + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 344, 146}); + + dieListe.anhaengen(232); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 344, 146, 232}); + + dieListe.einfuegenBei(0, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 344, 146, 232}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 344, 146, 232, 446}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446, 646}); + + assertTrue("Fehler: Element 232 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(232)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446, 646, 226}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 232, 446, 646, 226}); + + assertFalse("Fehler: Element 658 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(658)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 232, 446, 646, 226}); + + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 232, 446, 646, 226, 670}); + + dieListe.einfuegenBei(0, 294); + Tester.pruefeListenInhalt(dieListe, new int[]{294, 228, 232, 446, 646, 226, 670}); + + dieListe.einfuegenBei(0, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 228, 232, 446, 646, 226, 670}); + + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + dieListe.einfuegenBei(3, 927); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 228, 927, 232, 446, 646, 226, 670}); + + assertFalse("Fehler: Element 815 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(815)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 927, 232, 446, 646, 226, 670}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 927, 232, 446, 226, 670}); + + dieListe.einfuegenBei(0, 389); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670}); + + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 736}); + + assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389)); + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 736, 369}); + + dieListe.einfuegenBei(8, 292); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369}); + + dieListe.einfuegenBei(1, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369}); + + dieListe.anhaengen(554); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554, 861}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554}); + + assertFalse("Fehler: Element 91 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(91)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(153); + Tester.pruefeListenInhalt(dieListe, new int[]{153}); + + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 145}); + + dieListe.anhaengen(309); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 145, 309}); + + dieListe.einfuegenBei(2, 106); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 145, 106, 309}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 106, 309}); + + assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140)); + assertTrue("Fehler: Element 309 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(309)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 106}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{153}); + + assertTrue("Fehler: Element 153 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(153)); + assertFalse("Fehler: Element 316 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(316)); + dieListe.einfuegenBei(1, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 462}); + + dieListe.anhaengen(988); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 462, 988}); + + dieListe.einfuegenBei(1, 123); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 123, 462, 988}); + + dieListe.einfuegenBei(2, 704); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 123, 704, 462, 988}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{736}); + + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100}); + + dieListe.einfuegenBei(1, 169); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 169, 100}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100}); + + dieListe.anhaengen(540); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 540}); + + dieListe.anhaengen(486); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 540, 486}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 486}); + + dieListe.einfuegenBei(0, 866); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 736, 100, 486}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{482}); + + assertTrue("Fehler: Element 482 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(482)); + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{482, 651}); + + assertFalse("Fehler: Element 459 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(459)); + assertTrue("Fehler: Element 482 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(482)); + dieListe.einfuegenBei(2, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{482, 651, 842}); + + dieListe.einfuegenBei(0, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 482, 651, 842}); + + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 482, 651, 842, 414}); + + dieListe.einfuegenBei(1, 310); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 651, 842, 414}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 651, 414}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 414}); + + assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415)); + assertTrue("Fehler: Element 310 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(310)); + dieListe.einfuegenBei(1, 33); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 33, 310, 482, 414}); + + assertFalse("Fehler: Element 439 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(439)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{33, 310, 482, 414}); + + assertTrue("Fehler: Element 414 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(414)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{310, 482, 414}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{310, 414}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{414}); + + dieListe.einfuegenBei(0, 474); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 414}); + + assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(545); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 414, 545}); + + dieListe.anhaengen(510); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 414, 545, 510}); + + dieListe.einfuegenBei(0, 5); + Tester.pruefeListenInhalt(dieListe, new int[]{5, 474, 414, 545, 510}); + + dieListe.einfuegenBei(0, 745); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 474, 414, 545, 510}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 414, 545, 510}); + + dieListe.anhaengen(962); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 414, 545, 510, 962}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 414, 545, 510, 962}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 510, 962}); + + dieListe.einfuegenBei(2, 700); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962}); + + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962, 440}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962}); + + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962, 127}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 962, 127}); + + dieListe.einfuegenBei(2, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 127}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 127, 217}); + + assertFalse("Fehler: Element 357 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(357)); + assertFalse("Fehler: Element 166 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(166)); + dieListe.einfuegenBei(5, 503); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22}); + + dieListe.einfuegenBei(9, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435}); + + dieListe.anhaengen(85); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85}); + + dieListe.einfuegenBei(11, 870); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870}); + + assertFalse("Fehler: Element 49 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(49)); + assertFalse("Fehler: Element 425 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(425)); + dieListe.anhaengen(878); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870, 878}); + + dieListe.anhaengen(49); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870, 878, 49}); + + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 870, 878, 49}); + + assertFalse("Fehler: Element 493 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(493)); + dieListe.anhaengen(421); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 870, 878, 49, 421}); + + assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{659}); + + assertFalse("Fehler: Element 32 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(32)); + assertFalse("Fehler: Element 899 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(899)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(155); + Tester.pruefeListenInhalt(dieListe, new int[]{155}); + + dieListe.einfuegenBei(0, 205); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155}); + + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertFalse("Fehler: Element 146 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(31); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557}); + + assertFalse("Fehler: Element 980 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(980)); + assertTrue("Fehler: Element 205 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(205)); + assertFalse("Fehler: Element 438 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(438)); + dieListe.anhaengen(55); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557, 55}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557, 55, 463}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463}); + + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463, 709}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463}); + + dieListe.anhaengen(624); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463, 624}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463, 624, 518}); + + assertTrue("Fehler: Element 463 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(463)); + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624, 518}); + + assertTrue("Fehler: Element 624 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(624)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624, 217}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624}); + + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 55, 624}); + + dieListe.einfuegenBei(0, 363); + Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 55, 624}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 624}); + + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 624, 719}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 73); + Tester.pruefeListenInhalt(dieListe, new int[]{73}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{73, 957}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{957}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 854}); + + dieListe.einfuegenBei(2, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 854, 741}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 741}); + + dieListe.einfuegenBei(0, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 854, 741}); + + dieListe.einfuegenBei(0, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 598, 854, 741}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 598, 854, 741, 874}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest9.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest9.java new file mode 100644 index 0000000..6b3a2a8 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/SubTest9.java @@ -0,0 +1,2773 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest9. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest9 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{21}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 515}); + + dieListe.einfuegenBei(2, 49); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 515, 49}); + + assertFalse("Fehler: Element 949 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(949)); + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 49}); + + dieListe.anhaengen(476); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 49, 476}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{49, 476}); + + dieListe.einfuegenBei(0, 927); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 49, 476}); + + dieListe.einfuegenBei(1, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 49, 476}); + + dieListe.einfuegenBei(2, 854); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 854, 49, 476}); + + dieListe.einfuegenBei(2, 624); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 624, 854, 49, 476}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 624, 854, 49, 476, 470}); + + dieListe.einfuegenBei(1, 558); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 558, 132, 624, 854, 49, 476, 470}); + + assertFalse("Fehler: Element 578 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(578)); + dieListe.einfuegenBei(0, 213); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 624, 854, 49, 476, 470}); + + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 624, 854, 49, 476, 470, 257}); + + dieListe.einfuegenBei(4, 742); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 742, 624, 854, 49, 476, 470, 257}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 742, 624, 854, 49, 476, 257}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 984); + Tester.pruefeListenInhalt(dieListe, new int[]{984}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(720); + Tester.pruefeListenInhalt(dieListe, new int[]{720}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854}); + + dieListe.anhaengen(821); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 821}); + + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 821, 799}); + + dieListe.einfuegenBei(3, 240); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 821, 240, 799}); + + dieListe.einfuegenBei(2, 490); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 490, 821, 240, 799}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 490, 821, 799}); + + dieListe.einfuegenBei(0, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799}); + + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799, 975}); + + dieListe.anhaengen(458); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799, 975, 458}); + + assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854)); + assertTrue("Fehler: Element 799 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(799)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458}); + + dieListe.anhaengen(44); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458, 44}); + + dieListe.einfuegenBei(8, 748); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458, 44, 748}); + + assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44)); + dieListe.einfuegenBei(6, 942); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.einfuegenBei(2, 844); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 844, 490, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.einfuegenBei(4, 89); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748, 907}); + + dieListe.einfuegenBei(4, 510); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 748, 907}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 748, 907, 496}); + + assertTrue("Fehler: Element 844 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(844)); + dieListe.einfuegenBei(11, 780); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496}); + + assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496)); + dieListe.anhaengen(142); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + + dieListe.einfuegenBei(5, 374); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + + dieListe.einfuegenBei(2, 887); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 887, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + + assertFalse("Fehler: Element 704 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(704)); + dieListe.einfuegenBei(0, 534); + Tester.pruefeListenInhalt(dieListe, new int[]{534, 844, 490, 887, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(746); + Tester.pruefeListenInhalt(dieListe, new int[]{746}); + + dieListe.anhaengen(941); + Tester.pruefeListenInhalt(dieListe, new int[]{746, 941}); + + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{746, 941, 828}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{941, 828}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{828}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 590); + Tester.pruefeListenInhalt(dieListe, new int[]{590}); + + dieListe.einfuegenBei(1, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562}); + + dieListe.anhaengen(895); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895}); + + dieListe.anhaengen(165); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895, 165}); + + dieListe.einfuegenBei(4, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895, 165, 574}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 165, 574}); + + dieListe.einfuegenBei(0, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574}); + + dieListe.einfuegenBei(2, 190); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 190, 562, 165, 574}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574}); + + dieListe.anhaengen(624); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574, 624}); + + dieListe.einfuegenBei(2, 494); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 494, 562, 165, 574, 624}); + + dieListe.anhaengen(330); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 494, 562, 165, 574, 624, 330}); + + dieListe.einfuegenBei(2, 409); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 330}); + + assertFalse("Fehler: Element 18 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(18)); + assertTrue("Fehler: Element 574 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(574)); + dieListe.einfuegenBei(8, 678); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330}); + + dieListe.anhaengen(979); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979}); + + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 19}); + + assertFalse("Fehler: Element 380 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(380)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979}); + + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21}); + + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499, 387}); + + dieListe.einfuegenBei(1, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499, 387}); + + assertTrue("Fehler: Element 330 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(330)); + dieListe.einfuegenBei(13, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 494, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387, 967}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 387, 967}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(287); + Tester.pruefeListenInhalt(dieListe, new int[]{287}); + + dieListe.einfuegenBei(0, 593); + Tester.pruefeListenInhalt(dieListe, new int[]{593, 287}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{593, 287, 196}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{593, 196}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(765); + Tester.pruefeListenInhalt(dieListe, new int[]{765}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{765, 575}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{575}); + + dieListe.einfuegenBei(0, 273); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 575}); + + dieListe.einfuegenBei(2, 39); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 575, 39}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 39}); + + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 39, 989}); + + assertFalse("Fehler: Element 897 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(897)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 989}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{989}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{989, 23}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{23}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 792); + Tester.pruefeListenInhalt(dieListe, new int[]{792}); + + dieListe.einfuegenBei(1, 615); + Tester.pruefeListenInhalt(dieListe, new int[]{792, 615}); + + assertTrue("Fehler: Element 615 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(615)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{792}); + + assertFalse("Fehler: Element 220 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(220)); + dieListe.einfuegenBei(0, 803); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792}); + + dieListe.einfuegenBei(2, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792, 398}); + + assertFalse("Fehler: Element 986 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(986)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792}); + + dieListe.einfuegenBei(1, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 42, 792}); + + assertTrue("Fehler: Element 42 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(42)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792}); + + dieListe.einfuegenBei(2, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792, 757}); + + dieListe.anhaengen(35); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792, 757, 35}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 757, 35}); + + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 757, 35, 213}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213}); + + dieListe.anhaengen(632); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 632}); + + dieListe.einfuegenBei(3, 559); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632}); + + assertTrue("Fehler: Element 213 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(213)); + dieListe.anhaengen(141); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632, 141}); + + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632, 141, 388}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 632, 141, 388}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 141, 388}); + + dieListe.anhaengen(961); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 141, 388, 961}); + + assertTrue("Fehler: Element 35 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(35)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 388, 961}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 388, 961}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 388, 961, 349}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349}); + + dieListe.anhaengen(175); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349, 175}); + + dieListe.anhaengen(488); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349, 175, 488}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 175, 488}); + + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 175, 488, 466}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 175, 488, 466}); + + dieListe.einfuegenBei(2, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 689, 175, 488, 466}); + + dieListe.einfuegenBei(2, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 175, 488, 466}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466}); + + dieListe.anhaengen(119); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119}); + + assertFalse("Fehler: Element 878 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(878)); + dieListe.anhaengen(715); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.anhaengen(375); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 375}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 375, 152}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 152}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 152, 43}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 715, 152, 43}); + + dieListe.einfuegenBei(6, 136); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 136, 715, 152, 43}); + + dieListe.einfuegenBei(6, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 16, 136, 715, 152, 43}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 136, 715, 152, 43}); + + dieListe.einfuegenBei(6, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 956, 136, 715, 152, 43}); + + dieListe.einfuegenBei(10, 160); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 956, 136, 715, 152, 160, 43}); + + dieListe.einfuegenBei(6, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 136, 715, 152, 160, 43}); + + dieListe.anhaengen(632); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 136, 715, 152, 160, 43, 632}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632}); + + dieListe.anhaengen(809); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809}); + + dieListe.anhaengen(578); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578}); + + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578, 604}); + + dieListe.anhaengen(726); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578, 604, 726}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 604, 726}); + + dieListe.anhaengen(273); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 604, 726, 273}); + + dieListe.einfuegenBei(14, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 238, 604, 726, 273}); + + dieListe.einfuegenBei(18, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 238, 604, 726, 273, 435}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 359}); + + assertFalse("Fehler: Element 521 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(521)); + dieListe.anhaengen(443); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 359, 443}); + + dieListe.einfuegenBei(17, 423); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 423, 359, 443}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443}); + + assertTrue("Fehler: Element 632 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(632)); + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443, 769}); + + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443, 769, 482}); + + dieListe.einfuegenBei(11, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 239, 238, 604, 726, 435, 423, 359, 443, 769, 482}); + + assertTrue("Fehler: Element 769 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(769)); + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 239, 238, 604, 726, 435, 359, 443, 769, 482}); + + dieListe.einfuegenBei(10, 504); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 504, 578, 239, 238, 604, 726, 435, 359, 443, 769, 482}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 504, 578, 239, 238, 604, 726, 359, 443, 769, 482}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + assertTrue("Fehler: Element 466 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(466)); + assertFalse("Fehler: Element 281 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(281)); + dieListe.einfuegenBei(10, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769, 482}); + + dieListe.entferneBei(20); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769}); + + dieListe.einfuegenBei(8, 301); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 301, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{397}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 67); + Tester.pruefeListenInhalt(dieListe, new int[]{67}); + + assertTrue("Fehler: Element 67 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(67)); + assertFalse("Fehler: Element 748 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(748)); + dieListe.einfuegenBei(0, 304); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67}); + + dieListe.einfuegenBei(2, 69); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69}); + + dieListe.anhaengen(577); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69, 577}); + + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69, 577, 436}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 577, 436}); + + dieListe.anhaengen(260); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 577, 436, 260}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260}); + + dieListe.anhaengen(541); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260, 541}); + + dieListe.anhaengen(943); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260, 541, 943}); + + assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943, 372}); + + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943, 372, 846}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 372, 846}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 372, 846, 689}); + + dieListe.einfuegenBei(4, 57); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 57, 372, 846, 689}); + + dieListe.einfuegenBei(0, 262); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 846, 689}); + + assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689}); + + dieListe.anhaengen(129); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 129}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437}); + + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437, 952}); + + dieListe.anhaengen(807); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437, 952, 807}); + + dieListe.einfuegenBei(7, 72); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952, 807}); + + assertFalse("Fehler: Element 886 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(886)); + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952}); + + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952, 709}); + + assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262)); + dieListe.einfuegenBei(10, 821); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 821, 952, 709}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 372, 72, 689, 437, 821, 952, 709}); + + dieListe.anhaengen(898); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 372, 72, 689, 437, 821, 952, 709, 898}); + + assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72)); + dieListe.einfuegenBei(5, 139); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 139, 372, 72, 689, 437, 821, 952, 709, 898}); + + dieListe.einfuegenBei(2, 886); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 689, 437, 821, 952, 709, 898}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 689, 821, 952, 709, 898}); + + dieListe.einfuegenBei(9, 836); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 898}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 898}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709}); + + assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943)); + assertFalse("Fehler: Element 237 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(237)); + dieListe.einfuegenBei(13, 803); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803}); + + dieListe.anhaengen(918); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803, 918}); + + assertFalse("Fehler: Element 799 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(799)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803, 918}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 821, 709, 803, 918}); + + assertTrue("Fehler: Element 918 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(918)); + assertFalse("Fehler: Element 652 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(652)); + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918}); + + dieListe.anhaengen(578); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578}); + + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954}); + + dieListe.einfuegenBei(10, 961); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 961, 803, 918, 578, 954}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 961, 803, 918, 578, 954}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954}); + + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178}); + + dieListe.anhaengen(733); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178, 733}); + + assertTrue("Fehler: Element 803 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(803)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178, 733}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + assertFalse("Fehler: Element 50 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(50)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 372, 72, 836, 689, 709, 803, 918, 954, 178, 733}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{467}); + + dieListe.einfuegenBei(1, 927); + Tester.pruefeListenInhalt(dieListe, new int[]{467, 927}); + + dieListe.einfuegenBei(0, 242); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 467, 927}); + + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 467, 927, 474}); + + assertFalse("Fehler: Element 72 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(72)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 467, 927}); + + assertFalse("Fehler: Element 342 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(342)); + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 927}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{242}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 111); + Tester.pruefeListenInhalt(dieListe, new int[]{111}); + + assertFalse("Fehler: Element 34 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(34)); + dieListe.einfuegenBei(1, 591); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 591}); + + dieListe.einfuegenBei(1, 308); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 308, 591}); + + dieListe.einfuegenBei(1, 819); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 819, 308, 591}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 819, 308}); + + assertTrue("Fehler: Element 819 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(819)); + dieListe.einfuegenBei(1, 225); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 225, 819, 308}); + + assertTrue("Fehler: Element 111 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(111)); + dieListe.einfuegenBei(1, 680); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 308}); + + assertTrue("Fehler: Element 680 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(680)); + dieListe.einfuegenBei(1, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 686, 680, 225, 819, 308}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 308}); + + dieListe.einfuegenBei(4, 816); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 816, 308}); + + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 816, 308, 124}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 225, 819, 816, 308, 124}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 124}); + + dieListe.einfuegenBei(4, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 19, 124}); + + dieListe.einfuegenBei(4, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 569, 19, 124}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 298); + Tester.pruefeListenInhalt(dieListe, new int[]{298}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(735); + Tester.pruefeListenInhalt(dieListe, new int[]{735}); + + dieListe.einfuegenBei(0, 474); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 735}); + + dieListe.einfuegenBei(0, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735}); + + dieListe.anhaengen(201); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735, 201}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735}); + + dieListe.einfuegenBei(0, 103); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735}); + + dieListe.anhaengen(54); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54}); + + assertTrue("Fehler: Element 735 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(735)); + assertTrue("Fehler: Element 474 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(474)); + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54, 940}); + + assertTrue("Fehler: Element 562 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(562)); + dieListe.einfuegenBei(5, 631); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54, 631, 940}); + + assertFalse("Fehler: Element 250 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(250)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940}); + + dieListe.einfuegenBei(6, 30); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 30}); + + dieListe.anhaengen(966); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 30, 966}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966}); + + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966, 931}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966, 931, 748}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 940, 966, 931, 748}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 735, 54, 940, 966, 931, 748}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 940, 966, 931, 748}); + + dieListe.einfuegenBei(5, 214); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 940, 966, 931, 214, 748}); + + dieListe.einfuegenBei(2, 28); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 931, 214, 748}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 214, 748}); + + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 214, 748, 397}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{413}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(950); + Tester.pruefeListenInhalt(dieListe, new int[]{950}); + + dieListe.einfuegenBei(0, 480); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950}); + + dieListe.anhaengen(962); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 962}); + + assertFalse("Fehler: Element 287 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(287)); + assertTrue("Fehler: Element 962 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(962)); + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 962, 581}); + + dieListe.einfuegenBei(2, 163); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 163, 962, 581}); + + dieListe.einfuegenBei(1, 678); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 678, 950, 163, 962, 581}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 267); + Tester.pruefeListenInhalt(dieListe, new int[]{267}); + + dieListe.einfuegenBei(1, 595); + Tester.pruefeListenInhalt(dieListe, new int[]{267, 595}); + + assertTrue("Fehler: Element 595 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(595)); + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{267, 595, 812}); + + assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{267, 812}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{267}); + + assertFalse("Fehler: Element 82 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(82)); + assertFalse("Fehler: Element 256 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(256)); + dieListe.einfuegenBei(0, 968); + Tester.pruefeListenInhalt(dieListe, new int[]{968, 267}); + + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 715); + Tester.pruefeListenInhalt(dieListe, new int[]{715}); + + dieListe.einfuegenBei(0, 56); + Tester.pruefeListenInhalt(dieListe, new int[]{56, 715}); + + dieListe.einfuegenBei(0, 332); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715}); + + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715, 757}); + + dieListe.anhaengen(844); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715, 757, 844}); + + dieListe.einfuegenBei(1, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 771, 56, 715, 757, 844}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715, 757, 844}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 844}); + + assertTrue("Fehler: Element 332 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(332)); + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + dieListe.einfuegenBei(4, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 844, 175}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175}); + + dieListe.einfuegenBei(2, 774); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 774, 757, 175}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175}); + + assertTrue("Fehler: Element 56 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(56)); + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175, 711}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 711}); + + dieListe.anhaengen(980); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 711, 980}); + + dieListe.einfuegenBei(1, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 56, 757, 711, 980}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 980}); + + dieListe.anhaengen(778); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 980, 778}); + + assertTrue("Fehler: Element 980 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(980)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 778}); + + dieListe.anhaengen(241); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 778, 241}); + + dieListe.einfuegenBei(4, 142); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 142, 778, 241}); + + assertFalse("Fehler: Element 727 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(727)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 142, 778, 241}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 142, 778, 241, 689}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 778, 241, 689}); + + assertTrue("Fehler: Element 238 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(238)); + dieListe.einfuegenBei(2, 843); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689, 267}); + + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + assertFalse("Fehler: Element 925 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(925)); + dieListe.anhaengen(316); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689, 267, 316}); + + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 778, 241, 689, 267, 316}); + + assertFalse("Fehler: Element 460 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(460)); + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + dieListe.einfuegenBei(5, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 778, 241, 368, 689, 267, 316}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 241, 368, 689, 267, 316}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.einfuegenBei(2, 902); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 902, 711, 241, 368, 689, 267, 316}); + + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 902, 711, 241, 368, 689, 267, 316, 905}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 321); + Tester.pruefeListenInhalt(dieListe, new int[]{321}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{194}); + + dieListe.einfuegenBei(0, 694); + Tester.pruefeListenInhalt(dieListe, new int[]{694, 194}); + + assertFalse("Fehler: Element 927 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(927)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{194}); + + assertFalse("Fehler: Element 555 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(555)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{411}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{598}); + + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{413}); + + assertFalse("Fehler: Element 340 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(340)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 163); + Tester.pruefeListenInhalt(dieListe, new int[]{163}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{766}); + + assertTrue("Fehler: Element 766 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(766)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{496}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{496, 347}); + + assertFalse("Fehler: Element 196 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(196)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{347}); + + dieListe.einfuegenBei(1, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{347, 247}); + + assertTrue("Fehler: Element 347 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(347)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{347}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(316); + Tester.pruefeListenInhalt(dieListe, new int[]{316}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(210); + Tester.pruefeListenInhalt(dieListe, new int[]{210}); + + assertFalse("Fehler: Element 326 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(326)); + dieListe.einfuegenBei(1, 349); + Tester.pruefeListenInhalt(dieListe, new int[]{210, 349}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{210}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{277}); + + assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(594); + Tester.pruefeListenInhalt(dieListe, new int[]{594}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154}); + + dieListe.einfuegenBei(1, 586); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 586, 154}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154}); + + dieListe.einfuegenBei(1, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 390, 154}); + + assertFalse("Fehler: Element 637 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(637)); + dieListe.einfuegenBei(0, 179); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 390, 154}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154}); + + dieListe.anhaengen(564); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564}); + + dieListe.einfuegenBei(4, 249); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564, 249}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 564}); + + dieListe.einfuegenBei(2, 9); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564}); + + dieListe.anhaengen(772); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564, 772}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564}); + + dieListe.anhaengen(601); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564, 601}); + + assertFalse("Fehler: Element 178 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(178)); + assertTrue("Fehler: Element 594 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(594)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 601}); + + dieListe.anhaengen(438); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 601, 438}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 438}); + + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 438, 116}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116}); + + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 748}); + + dieListe.anhaengen(412); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 748, 412}); + + assertTrue("Fehler: Element 748 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(748)); + dieListe.einfuegenBei(5, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 736, 748, 412}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 438, 116, 732, 736, 748, 412}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 412}); + + assertFalse("Fehler: Element 445 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(445)); + assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52)); + dieListe.anhaengen(394); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 412, 394}); + + dieListe.einfuegenBei(5, 352); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 412, 394}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 394}); + + dieListe.anhaengen(421); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 394, 421}); + + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421}); + + assertFalse("Fehler: Element 629 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(629)); + dieListe.anhaengen(377); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377}); + + dieListe.anhaengen(282); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377, 282}); + + dieListe.anhaengen(735); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377, 282, 735}); + + assertTrue("Fehler: Element 9 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(9)); + dieListe.einfuegenBei(3, 170); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 735}); + + assertTrue("Fehler: Element 116 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(116)); + dieListe.anhaengen(737); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 735, 737}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737}); + + dieListe.anhaengen(78); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737, 78}); + + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737, 78, 71}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 421, 377, 282, 737, 78, 71}); + + dieListe.einfuegenBei(6, 369); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 737, 78, 71}); + + dieListe.einfuegenBei(10, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71}); + + dieListe.anhaengen(364); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364}); + + assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275)); + dieListe.einfuegenBei(3, 727); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364}); + + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 958}); + + dieListe.einfuegenBei(16, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958}); + + dieListe.anhaengen(147); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958, 147}); + + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958, 147, 382}); + + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 147, 382}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(981); + Tester.pruefeListenInhalt(dieListe, new int[]{981}); + + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.einfuegenBei(0, 672); + Tester.pruefeListenInhalt(dieListe, new int[]{672, 981}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{981}); + + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{981, 633}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{981}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{26}); + + dieListe.einfuegenBei(1, 55); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 55}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 184); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + dieListe.einfuegenBei(0, 717); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184}); + + dieListe.einfuegenBei(2, 994); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 994}); + + assertFalse("Fehler: Element 700 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(700)); + assertFalse("Fehler: Element 574 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(574)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184}); + + dieListe.einfuegenBei(2, 641); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 641}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184}); + + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 97}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 97, 166}); + + assertFalse("Fehler: Element 178 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(178)); + dieListe.einfuegenBei(1, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 97, 166}); + + assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765)); + dieListe.einfuegenBei(1, 106); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 97, 166}); + + dieListe.einfuegenBei(6, 495); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 97, 166, 495}); + + dieListe.einfuegenBei(4, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 360, 97, 166, 495}); + + dieListe.einfuegenBei(4, 440); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 440, 360, 97, 166, 495}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 440, 360, 97, 166, 495}); + + assertFalse("Fehler: Element 195 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(195)); + dieListe.einfuegenBei(2, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 652, 184, 440, 360, 97, 166, 495}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 440, 360, 97, 166, 495}); + + dieListe.einfuegenBei(1, 824); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 184, 440, 360, 97, 166, 495}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + assertFalse("Fehler: Element 315 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(315)); + assertFalse("Fehler: Element 496 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(496)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495}); + + dieListe.anhaengen(717); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495, 717}); + + dieListe.anhaengen(805); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495, 717, 805}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 805}); + + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 805, 968}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 968}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 495, 717, 968}); + + dieListe.einfuegenBei(6, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 495, 723, 717, 968}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 495, 723, 717, 968}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 495, 723, 968}); + + dieListe.einfuegenBei(2, 46); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 46, 360, 97, 495, 723, 968}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 46, 360, 97, 723, 968}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 723, 968}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 97, 723, 968}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 97, 723, 968}); + + assertTrue("Fehler: Element 723 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(723)); + assertTrue("Fehler: Element 717 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(717)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 723, 968}); + + assertTrue("Fehler: Element 97 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(97)); + dieListe.einfuegenBei(2, 236); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 723, 236, 968}); + + dieListe.einfuegenBei(0, 103); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236, 968}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236, 990}); + + dieListe.einfuegenBei(1, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990}); + + dieListe.einfuegenBei(6, 626); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990, 626}); + + dieListe.einfuegenBei(6, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990, 19, 626}); + + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{116}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.einfuegenBei(1, 512); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 512}); + + dieListe.einfuegenBei(0, 830); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 116, 512}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 512}); + + dieListe.anhaengen(455); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 512, 455}); + + dieListe.einfuegenBei(3, 682); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 512, 455, 682}); + + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + dieListe.einfuegenBei(1, 931); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 931, 512, 455, 682}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 931, 512, 682}); + + dieListe.einfuegenBei(1, 566); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 566, 931, 512, 682}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 566, 931, 512, 682, 349}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 931, 512, 682, 349}); + + dieListe.einfuegenBei(3, 388); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 931, 512, 388, 682, 349}); + + dieListe.einfuegenBei(0, 618); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 566, 931, 512, 388, 682, 349}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 566, 931, 512, 388, 682}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 104); + Tester.pruefeListenInhalt(dieListe, new int[]{104}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 189}); + + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 189, 922}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 922}); + + assertFalse("Fehler: Element 490 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(490)); + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + dieListe.einfuegenBei(1, 910); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 922}); + + dieListe.einfuegenBei(2, 662); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662, 922}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662}); + + dieListe.einfuegenBei(1, 820); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 820, 910, 662}); + + assertTrue("Fehler: Element 910 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(910)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662}); + + dieListe.anhaengen(358); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662, 358}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 662}); + + assertFalse("Fehler: Element 846 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(846)); + assertFalse("Fehler: Element 77 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(77)); + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 662, 473}); + + dieListe.anhaengen(802); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 662, 473, 802}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 278); + Tester.pruefeListenInhalt(dieListe, new int[]{278}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{664}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 274); + Tester.pruefeListenInhalt(dieListe, new int[]{274}); + + dieListe.einfuegenBei(1, 839); + Tester.pruefeListenInhalt(dieListe, new int[]{274, 839}); + + dieListe.einfuegenBei(1, 565); + Tester.pruefeListenInhalt(dieListe, new int[]{274, 565, 839}); + + dieListe.einfuegenBei(0, 136); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 274, 565, 839}); + + dieListe.einfuegenBei(1, 93); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 565, 839}); + + dieListe.einfuegenBei(3, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 208, 565, 839}); + + dieListe.einfuegenBei(1, 320); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 320, 93, 274, 208, 565, 839}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 320, 93, 274, 208, 565}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 208, 565}); + + dieListe.einfuegenBei(1, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 976, 93, 274, 208, 565}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(134); + Tester.pruefeListenInhalt(dieListe, new int[]{134}); + + dieListe.einfuegenBei(0, 851); + Tester.pruefeListenInhalt(dieListe, new int[]{851, 134}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{134}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{502}); + + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 763}); + + dieListe.einfuegenBei(2, 154); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 763, 154}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154}); + + dieListe.anhaengen(38); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 38}); + + assertFalse("Fehler: Element 975 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(975)); + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 38, 608}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 608}); + + dieListe.einfuegenBei(3, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 608, 467}); + + assertFalse("Fehler: Element 715 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(715)); + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 467}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 837}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 837}); + + dieListe.einfuegenBei(1, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 144, 837}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 144}); + + dieListe.einfuegenBei(0, 957); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 502, 144}); + + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 144}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{144}); + + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(216); + Tester.pruefeListenInhalt(dieListe, new int[]{216}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(754); + Tester.pruefeListenInhalt(dieListe, new int[]{754}); + + dieListe.einfuegenBei(1, 375); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375}); + + assertTrue("Fehler: Element 375 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(375)); + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922}); + + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288}); + + dieListe.anhaengen(18); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288, 18}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288, 18, 490}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 18, 490}); + + dieListe.anhaengen(841); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 18, 490, 841}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 490, 841}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 490, 841, 23}); + + dieListe.einfuegenBei(3, 595); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 841, 23}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 841, 23, 314}); + + dieListe.einfuegenBei(5, 674); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 674, 841, 23, 314}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + assertTrue("Fehler: Element 314 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(314)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 674, 841, 23, 314}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 841, 23, 314}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314}); + + assertFalse("Fehler: Element 107 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(107)); + dieListe.anhaengen(858); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314, 858}); + + dieListe.anhaengen(892); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314, 858, 892}); + + dieListe.einfuegenBei(1, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 490, 23, 314, 858, 892}); + + dieListe.anhaengen(875); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 490, 23, 314, 858, 892, 875}); + + dieListe.einfuegenBei(4, 64); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875}); + + dieListe.anhaengen(588); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588}); + + dieListe.einfuegenBei(12, 567); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588, 567}); + + dieListe.anhaengen(261); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588, 567, 261}); + + dieListe.einfuegenBei(10, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 588, 567, 261}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 588, 567, 261, 528}); + + dieListe.einfuegenBei(12, 88); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 88, 588, 567, 261, 528}); + + assertFalse("Fehler: Element 433 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(433)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528}); + + dieListe.anhaengen(630); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211}); + + assertTrue("Fehler: Element 375 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(375)); + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + assertFalse("Fehler: Element 25 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(25)); + dieListe.einfuegenBei(5, 332); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211}); + + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414}); + + assertTrue("Fehler: Element 211 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(211)); + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414, 449}); + + dieListe.einfuegenBei(16, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 77, 683, 211, 414, 449}); + + dieListe.einfuegenBei(1, 278); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 77, 683, 211, 414, 449}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 630, 77, 683, 211, 414, 449}); + + dieListe.anhaengen(34); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 630, 77, 683, 211, 414, 449, 34}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(491); + Tester.pruefeListenInhalt(dieListe, new int[]{491}); + + dieListe.einfuegenBei(1, 958); + Tester.pruefeListenInhalt(dieListe, new int[]{491, 958}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{491}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 73); + Tester.pruefeListenInhalt(dieListe, new int[]{73}); + + dieListe.anhaengen(235); + Tester.pruefeListenInhalt(dieListe, new int[]{73, 235}); + + dieListe.einfuegenBei(0, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 73, 235}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{665}); + + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{257}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{341}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{341, 341}); + + assertTrue("Fehler: Element 341 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(341)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(566); + Tester.pruefeListenInhalt(dieListe, new int[]{566}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{121}); + + dieListe.anhaengen(574); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935}); + + dieListe.einfuegenBei(3, 473); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473}); + + dieListe.anhaengen(655); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 655}); + + assertTrue("Fehler: Element 655 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(655)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646}); + + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646, 337}); + + dieListe.einfuegenBei(5, 490); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646, 490, 337}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 646, 490, 337}); + + dieListe.einfuegenBei(2, 72); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 935, 646, 490, 337}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + assertFalse("Fehler: Element 628 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(628)); + dieListe.anhaengen(313); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 935, 646, 490, 337, 313}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313, 909}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313}); + + dieListe.einfuegenBei(5, 331); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 331, 337, 313}); + + assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485)); + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 331, 337, 313, 86}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 72, 646, 490, 331, 337, 313, 86}); + + assertTrue("Fehler: Element 121 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(121)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 490, 331, 337, 313, 86}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 337, 313, 86}); + + dieListe.anhaengen(600); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 337, 313, 86, 600}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 313, 86, 600}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 437); + Tester.pruefeListenInhalt(dieListe, new int[]{437}); + + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{437, 788}); + + assertFalse("Fehler: Element 304 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(304)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{437, 788, 286}); + + assertFalse("Fehler: Element 526 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(526)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{788, 286}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{286}); + + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618}); + + dieListe.anhaengen(352); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352}); + + assertFalse("Fehler: Element 237 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(237)); + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 581}); + + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 581, 931}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 931}); + + assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618)); + dieListe.einfuegenBei(1, 861); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 861, 618, 352, 931}); + + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + dieListe.einfuegenBei(3, 190); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 861, 618, 190, 352, 931}); + + assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861)); + assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618)); + dieListe.einfuegenBei(1, 699); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 699, 861, 618, 190, 352, 931}); + + dieListe.einfuegenBei(2, 935); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 699, 935, 861, 618, 190, 352, 931}); + + dieListe.einfuegenBei(0, 653); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 190, 352, 931}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931}); + + assertTrue("Fehler: Element 286 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(286)); + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + dieListe.einfuegenBei(8, 959); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931, 959}); + + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931, 959, 337}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 931, 959, 337}); + + dieListe.einfuegenBei(4, 698); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337}); + + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333}); + + assertFalse("Fehler: Element 180 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(180)); + assertFalse("Fehler: Element 702 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(702)); + assertFalse("Fehler: Element 226 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(226)); + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623}); + + assertFalse("Fehler: Element 939 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(939)); + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623, 25}); + + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623, 25, 595}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595}); + + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595, 494}); + + assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618)); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595, 494, 440}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 959, 337, 333, 623, 25, 595, 494, 440}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440}); + + assertTrue("Fehler: Element 337 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(337)); + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838}); + + assertFalse("Fehler: Element 421 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(421)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838}); + + assertFalse("Fehler: Element 153 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(153)); + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(202); + Tester.pruefeListenInhalt(dieListe, new int[]{202}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 422); + Tester.pruefeListenInhalt(dieListe, new int[]{422}); + + assertFalse("Fehler: Element 558 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(558)); + assertTrue("Fehler: Element 422 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(422)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{707}); + + dieListe.einfuegenBei(1, 942); + Tester.pruefeListenInhalt(dieListe, new int[]{707, 942}); + + dieListe.einfuegenBei(0, 116); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 942}); + + dieListe.einfuegenBei(3, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 942, 536}); + + assertTrue("Fehler: Element 942 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(942)); + dieListe.einfuegenBei(2, 339); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339, 942, 536}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339, 536}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{116}); + + assertFalse("Fehler: Element 465 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(465)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 134); + Tester.pruefeListenInhalt(dieListe, new int[]{134}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(336); + Tester.pruefeListenInhalt(dieListe, new int[]{336}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{336, 417}); + + dieListe.anhaengen(592); + Tester.pruefeListenInhalt(dieListe, new int[]{336, 417, 592}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{417, 592}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{592}); + + dieListe.einfuegenBei(0, 901); + Tester.pruefeListenInhalt(dieListe, new int[]{901, 592}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{592}); + + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + assertTrue("Fehler: Element 592 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(592)); + assertFalse("Fehler: Element 169 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(169)); + dieListe.einfuegenBei(1, 634); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 634}); + + assertTrue("Fehler: Element 592 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(592)); + dieListe.einfuegenBei(2, 862); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 634, 862}); + + assertFalse("Fehler: Element 574 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(574)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 634}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{592}); + + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 866}); + + dieListe.anhaengen(785); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 866, 785}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 785}); + + dieListe.einfuegenBei(0, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785, 189}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 785}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{866}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 923}); + + dieListe.einfuegenBei(1, 904); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 904, 923}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923}); + + dieListe.einfuegenBei(2, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923, 884}); + + dieListe.anhaengen(778); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923, 884, 778}); + + assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778)); + assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923, 884}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 884}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{904}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{956}); + + assertTrue("Fehler: Element 956 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(956)); + dieListe.einfuegenBei(1, 140); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 140}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{140}); + + assertFalse("Fehler: Element 797 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(797)); + dieListe.einfuegenBei(1, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{140, 174}); + + dieListe.anhaengen(893); + Tester.pruefeListenInhalt(dieListe, new int[]{140, 174, 893}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 893}); + + dieListe.anhaengen(892); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 893, 892}); + + dieListe.einfuegenBei(3, 769); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 893, 892, 769}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 892, 769}); + + assertFalse("Fehler: Element 429 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(429)); + dieListe.anhaengen(193); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 892, 769, 193}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 892, 769, 193, 676}); + + dieListe.einfuegenBei(0, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 893, 892, 769, 193, 676}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 893, 892, 769, 676}); + + dieListe.einfuegenBei(1, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 481, 893, 892, 769, 676}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 769, 676}); + + dieListe.einfuegenBei(3, 637); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 676}); + + assertFalse("Fehler: Element 870 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(870)); + dieListe.anhaengen(477); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 676, 477}); + + dieListe.einfuegenBei(5, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 59, 676, 477}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 892, 637, 769, 59, 676, 477}); + + assertTrue("Fehler: Element 676 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(676)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 769, 59, 676, 477}); + + dieListe.einfuegenBei(2, 540); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 769, 59, 676, 477}); + + assertFalse("Fehler: Element 861 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(861)); + dieListe.einfuegenBei(7, 857); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 769, 59, 676, 477, 857}); + + dieListe.einfuegenBei(3, 674); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 59, 676, 477, 857}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.einfuegenBei(5, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 477, 857}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 477}); + + assertTrue("Fehler: Element 674 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(674)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676}); + + dieListe.einfuegenBei(3, 921); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 921, 674, 769, 382, 59, 676}); + + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676}); + + dieListe.einfuegenBei(8, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77}); + + assertTrue("Fehler: Element 769 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(769)); + dieListe.anhaengen(791); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 791}); + + dieListe.einfuegenBei(10, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 791, 702}); + + assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553)); + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 702}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{957}); + + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 306}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{306}); + + dieListe.anhaengen(72); + Tester.pruefeListenInhalt(dieListe, new int[]{306, 72}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{306}); + + assertFalse("Fehler: Element 550 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(550)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 149); + Tester.pruefeListenInhalt(dieListe, new int[]{149}); + + dieListe.anhaengen(61); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61}); + + dieListe.anhaengen(671); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671}); + + assertTrue("Fehler: Element 61 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(61)); + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + dieListe.anhaengen(674); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671, 674}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671}); + + dieListe.anhaengen(510); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671, 510}); + + dieListe.einfuegenBei(1, 519); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 671, 510}); + + dieListe.anhaengen(460); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 671, 510, 460}); + + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + dieListe.einfuegenBei(3, 676); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 676, 671, 510, 460}); + + dieListe.einfuegenBei(3, 717); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 510, 460}); + + dieListe.einfuegenBei(6, 941); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460}); + + assertFalse("Fehler: Element 836 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(836)); + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470, 852}); + + assertFalse("Fehler: Element 894 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(894)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470}); + + dieListe.einfuegenBei(4, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 671, 941, 510, 460, 470}); + + dieListe.einfuegenBei(7, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 671, 396, 941, 510, 460, 470}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 470}); + + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 470, 659}); + + assertFalse("Fehler: Element 588 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(588)); + dieListe.einfuegenBei(10, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 398, 470, 659}); + + assertTrue("Fehler: Element 398 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(398)); + dieListe.einfuegenBei(12, 366); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 398, 470, 366, 659}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(795); + Tester.pruefeListenInhalt(dieListe, new int[]{795}); + + assertTrue("Fehler: Element 795 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(795)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{526}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 661); + Tester.pruefeListenInhalt(dieListe, new int[]{661}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 893); + Tester.pruefeListenInhalt(dieListe, new int[]{893}); + + dieListe.einfuegenBei(0, 502); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99}); + + dieListe.anhaengen(808); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 808}); + + dieListe.einfuegenBei(5, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 808, 21}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 21}); + + dieListe.einfuegenBei(2, 211); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854, 99, 21}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854, 99}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 211, 854}); + + assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{211, 854}); + + dieListe.einfuegenBei(2, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{211, 854, 922}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 922}); + + assertFalse("Fehler: Element 386 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(386)); + dieListe.einfuegenBei(0, 831); + Tester.pruefeListenInhalt(dieListe, new int[]{831, 854, 922}); + + dieListe.einfuegenBei(1, 252); + Tester.pruefeListenInhalt(dieListe, new int[]{831, 252, 854, 922}); + + dieListe.einfuegenBei(0, 370); + Tester.pruefeListenInhalt(dieListe, new int[]{370, 831, 252, 854, 922}); + + assertFalse("Fehler: Element 492 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(492)); + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{370, 252, 854, 922}); + + assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{370, 252, 854, 922, 395}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395}); + + dieListe.einfuegenBei(4, 207); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974}); + + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290}); + + dieListe.einfuegenBei(3, 915); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290}); + + dieListe.einfuegenBei(7, 784); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 784, 290}); + + assertFalse("Fehler: Element 870 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(870)); + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 784, 290, 708}); + + assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290, 708}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290}); + + dieListe.anhaengen(722); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290, 722}); + + dieListe.anhaengen(663); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290, 722, 663}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 722, 663}); + + dieListe.anhaengen(746); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 722, 663, 746}); + + dieListe.einfuegenBei(6, 377); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746}); + + assertTrue("Fehler: Element 974 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(974)); + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271}); + + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271, 708}); + + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + dieListe.einfuegenBei(11, 974); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271, 974, 708}); + + dieListe.einfuegenBei(8, 426); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 426, 663, 746, 271, 974, 708}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 746, 271, 974, 708}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 271, 974, 708}); + + dieListe.einfuegenBei(9, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708}); + + dieListe.einfuegenBei(13, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666}); + + assertTrue("Fehler: Element 252 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(252)); + dieListe.einfuegenBei(0, 717); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666}); + + assertTrue("Fehler: Element 426 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(426)); + assertTrue("Fehler: Element 974 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(974)); + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666, 659}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/Tester.java b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/Tester.java new file mode 100644 index 0000000..eeebb1f --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/Tester.java @@ -0,0 +1,530 @@ +package tests; + +import liste.*; +import tests.*; + +import static org.junit.Assert.*; + +import org.junit.Test; + +/** + * Die Test-Klasse Tester. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public abstract class Tester { + protected Liste dieListe; + + protected static void pruefeListenInhalt(Liste dieListe, int[] erwartet) { + if (erwartet.length == 0) + assertTrue(dieListe.istLeer()); + else + assertFalse(dieListe.istLeer()); + assertEquals("Fehler: Länge stimmt nicht.", erwartet.length, dieListe.laenge()); + for (int i = 0; i < erwartet.length; i++) { + assertEquals("Fehler: Element an Index " + i + " stimmt nicht.", erwartet[i], dieListe.getNtenWert(i).intValue()); + } + } + + @Test + public void test001() { + SubTest1.test1Durchfuehren(dieListe); + } + + @Test + public void test002() { + SubTest1.test2Durchfuehren(dieListe); + } + + @Test + public void test003() { + SubTest1.test3Durchfuehren(dieListe); + } + + @Test + public void test004() { + SubTest1.test4Durchfuehren(dieListe); + } + + @Test + public void test005() { + SubTest1.test5Durchfuehren(dieListe); + } + + @Test + public void test006() { + SubTest1.test6Durchfuehren(dieListe); + } + + @Test + public void test007() { + SubTest1.test7Durchfuehren(dieListe); + } + + @Test + public void test008() { + SubTest1.test8Durchfuehren(dieListe); + } + + @Test + public void test009() { + SubTest1.test9Durchfuehren(dieListe); + } + + @Test + public void test010() { + SubTest1.test10Durchfuehren(dieListe); + } + + @Test + public void test011() { + SubTest2.test1Durchfuehren(dieListe); + } + + @Test + public void test012() { + SubTest2.test2Durchfuehren(dieListe); + } + + @Test + public void test013() { + SubTest2.test3Durchfuehren(dieListe); + } + + @Test + public void test014() { + SubTest2.test4Durchfuehren(dieListe); + } + + @Test + public void test015() { + SubTest2.test5Durchfuehren(dieListe); + } + + @Test + public void test016() { + SubTest2.test6Durchfuehren(dieListe); + } + + @Test + public void test017() { + SubTest2.test7Durchfuehren(dieListe); + } + + @Test + public void test018() { + SubTest2.test8Durchfuehren(dieListe); + } + + @Test + public void test019() { + SubTest2.test9Durchfuehren(dieListe); + } + + @Test + public void test020() { + SubTest2.test10Durchfuehren(dieListe); + } + + @Test + public void test021() { + SubTest3.test1Durchfuehren(dieListe); + } + + @Test + public void test022() { + SubTest3.test2Durchfuehren(dieListe); + } + + @Test + public void test023() { + SubTest3.test3Durchfuehren(dieListe); + } + + @Test + public void test024() { + SubTest3.test4Durchfuehren(dieListe); + } + + @Test + public void test025() { + SubTest3.test5Durchfuehren(dieListe); + } + + @Test + public void test026() { + SubTest3.test6Durchfuehren(dieListe); + } + + @Test + public void test027() { + SubTest3.test7Durchfuehren(dieListe); + } + + @Test + public void test028() { + SubTest3.test8Durchfuehren(dieListe); + } + + @Test + public void test029() { + SubTest3.test9Durchfuehren(dieListe); + } + + @Test + public void test030() { + SubTest3.test10Durchfuehren(dieListe); + } + + @Test + public void test031() { + SubTest4.test1Durchfuehren(dieListe); + } + + @Test + public void test032() { + SubTest4.test2Durchfuehren(dieListe); + } + + @Test + public void test033() { + SubTest4.test3Durchfuehren(dieListe); + } + + @Test + public void test034() { + SubTest4.test4Durchfuehren(dieListe); + } + + @Test + public void test035() { + SubTest4.test5Durchfuehren(dieListe); + } + + @Test + public void test036() { + SubTest4.test6Durchfuehren(dieListe); + } + + @Test + public void test037() { + SubTest4.test7Durchfuehren(dieListe); + } + + @Test + public void test038() { + SubTest4.test8Durchfuehren(dieListe); + } + + @Test + public void test039() { + SubTest4.test9Durchfuehren(dieListe); + } + + @Test + public void test040() { + SubTest4.test10Durchfuehren(dieListe); + } + + @Test + public void test041() { + SubTest5.test1Durchfuehren(dieListe); + } + + @Test + public void test042() { + SubTest5.test2Durchfuehren(dieListe); + } + + @Test + public void test043() { + SubTest5.test3Durchfuehren(dieListe); + } + + @Test + public void test044() { + SubTest5.test4Durchfuehren(dieListe); + } + + @Test + public void test045() { + SubTest5.test5Durchfuehren(dieListe); + } + + @Test + public void test046() { + SubTest5.test6Durchfuehren(dieListe); + } + + @Test + public void test047() { + SubTest5.test7Durchfuehren(dieListe); + } + + @Test + public void test048() { + SubTest5.test8Durchfuehren(dieListe); + } + + @Test + public void test049() { + SubTest5.test9Durchfuehren(dieListe); + } + + @Test + public void test050() { + SubTest5.test10Durchfuehren(dieListe); + } + + @Test + public void test051() { + SubTest6.test1Durchfuehren(dieListe); + } + + @Test + public void test052() { + SubTest6.test2Durchfuehren(dieListe); + } + + @Test + public void test053() { + SubTest6.test3Durchfuehren(dieListe); + } + + @Test + public void test054() { + SubTest6.test4Durchfuehren(dieListe); + } + + @Test + public void test055() { + SubTest6.test5Durchfuehren(dieListe); + } + + @Test + public void test056() { + SubTest6.test6Durchfuehren(dieListe); + } + + @Test + public void test057() { + SubTest6.test7Durchfuehren(dieListe); + } + + @Test + public void test058() { + SubTest6.test8Durchfuehren(dieListe); + } + + @Test + public void test059() { + SubTest6.test9Durchfuehren(dieListe); + } + + @Test + public void test060() { + SubTest6.test10Durchfuehren(dieListe); + } + + @Test + public void test061() { + SubTest7.test1Durchfuehren(dieListe); + } + + @Test + public void test062() { + SubTest7.test2Durchfuehren(dieListe); + } + + @Test + public void test063() { + SubTest7.test3Durchfuehren(dieListe); + } + + @Test + public void test064() { + SubTest7.test4Durchfuehren(dieListe); + } + + @Test + public void test065() { + SubTest7.test5Durchfuehren(dieListe); + } + + @Test + public void test066() { + SubTest7.test6Durchfuehren(dieListe); + } + + @Test + public void test067() { + SubTest7.test7Durchfuehren(dieListe); + } + + @Test + public void test068() { + SubTest7.test8Durchfuehren(dieListe); + } + + @Test + public void test069() { + SubTest7.test9Durchfuehren(dieListe); + } + + @Test + public void test070() { + SubTest7.test10Durchfuehren(dieListe); + } + + @Test + public void test071() { + SubTest8.test1Durchfuehren(dieListe); + } + + @Test + public void test072() { + SubTest8.test2Durchfuehren(dieListe); + } + + @Test + public void test073() { + SubTest8.test3Durchfuehren(dieListe); + } + + @Test + public void test074() { + SubTest8.test4Durchfuehren(dieListe); + } + + @Test + public void test075() { + SubTest8.test5Durchfuehren(dieListe); + } + + @Test + public void test076() { + SubTest8.test6Durchfuehren(dieListe); + } + + @Test + public void test077() { + SubTest8.test7Durchfuehren(dieListe); + } + + @Test + public void test078() { + SubTest8.test8Durchfuehren(dieListe); + } + + @Test + public void test079() { + SubTest8.test9Durchfuehren(dieListe); + } + + @Test + public void test080() { + SubTest8.test10Durchfuehren(dieListe); + } + + @Test + public void test081() { + SubTest9.test1Durchfuehren(dieListe); + } + + @Test + public void test082() { + SubTest9.test2Durchfuehren(dieListe); + } + + @Test + public void test083() { + SubTest9.test3Durchfuehren(dieListe); + } + + @Test + public void test084() { + SubTest9.test4Durchfuehren(dieListe); + } + + @Test + public void test085() { + SubTest9.test5Durchfuehren(dieListe); + } + + @Test + public void test086() { + SubTest9.test6Durchfuehren(dieListe); + } + + @Test + public void test087() { + SubTest9.test7Durchfuehren(dieListe); + } + + @Test + public void test088() { + SubTest9.test8Durchfuehren(dieListe); + } + + @Test + public void test089() { + SubTest9.test9Durchfuehren(dieListe); + } + + @Test + public void test090() { + SubTest9.test10Durchfuehren(dieListe); + } + + @Test + public void test091() { + SubTest10.test1Durchfuehren(dieListe); + } + + @Test + public void test092() { + SubTest10.test2Durchfuehren(dieListe); + } + + @Test + public void test093() { + SubTest10.test3Durchfuehren(dieListe); + } + + @Test + public void test094() { + SubTest10.test4Durchfuehren(dieListe); + } + + @Test + public void test095() { + SubTest10.test5Durchfuehren(dieListe); + } + + @Test + public void test096() { + SubTest10.test6Durchfuehren(dieListe); + } + + @Test + public void test097() { + SubTest10.test7Durchfuehren(dieListe); + } + + @Test + public void test098() { + SubTest10.test8Durchfuehren(dieListe); + } + + @Test + public void test099() { + SubTest10.test9Durchfuehren(dieListe); + } + + @Test + public void test100() { + SubTest10.test10Durchfuehren(dieListe); + } + +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/package.bluej b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/package.bluej new file mode 100644 index 0000000..fc31d31 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/01_verkettete_liste_roh/tests/package.bluej @@ -0,0 +1,157 @@ +#BlueJ package file +dependency1.from=SubTest6 +dependency1.to=Tester +dependency1.type=UsesDependency +dependency10.from=SubTest1 +dependency10.to=Tester +dependency10.type=UsesDependency +dependency11.from=Tester +dependency11.to=SubTest1 +dependency11.type=UsesDependency +dependency12.from=Tester +dependency12.to=SubTest2 +dependency12.type=UsesDependency +dependency13.from=Tester +dependency13.to=SubTest3 +dependency13.type=UsesDependency +dependency14.from=Tester +dependency14.to=SubTest4 +dependency14.type=UsesDependency +dependency15.from=Tester +dependency15.to=SubTest5 +dependency15.type=UsesDependency +dependency16.from=Tester +dependency16.to=SubTest6 +dependency16.type=UsesDependency +dependency17.from=Tester +dependency17.to=SubTest7 +dependency17.type=UsesDependency +dependency18.from=Tester +dependency18.to=SubTest8 +dependency18.type=UsesDependency +dependency19.from=Tester +dependency19.to=SubTest9 +dependency19.type=UsesDependency +dependency2.from=SubTest7 +dependency2.to=Tester +dependency2.type=UsesDependency +dependency20.from=Tester +dependency20.to=SubTest10 +dependency20.type=UsesDependency +dependency3.from=SubTest8 +dependency3.to=Tester +dependency3.type=UsesDependency +dependency4.from=SubTest9 +dependency4.to=Tester +dependency4.type=UsesDependency +dependency5.from=SubTest2 +dependency5.to=Tester +dependency5.type=UsesDependency +dependency6.from=SubTest3 +dependency6.to=Tester +dependency6.type=UsesDependency +dependency7.from=SubTest4 +dependency7.to=Tester +dependency7.type=UsesDependency +dependency8.from=SubTest5 +dependency8.to=Tester +dependency8.type=UsesDependency +dependency9.from=SubTest10 +dependency9.to=Tester +dependency9.type=UsesDependency +objectbench.height=114 +objectbench.width=1487 +package.divider.horizontal=0.6 +package.divider.vertical=0.8476070528967254 +package.editor.height=666 +package.editor.width=1376 +package.editor.x=157 +package.editor.y=40 +package.frame.height=894 +package.frame.width=1527 +package.numDependencies=20 +package.numTargets=11 +package.showExtends=true +package.showUses=true +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=SubTest6 +target1.showInterface=false +target1.type=ClassTarget +target1.width=80 +target1.x=330 +target1.y=340 +target10.height=50 +target10.name=SubTest10 +target10.showInterface=false +target10.type=ClassTarget +target10.width=90 +target10.x=690 +target10.y=340 +target11.height=50 +target11.name=SubTest1 +target11.showInterface=false +target11.type=ClassTarget +target11.width=80 +target11.x=330 +target11.y=280 +target2.height=50 +target2.name=SubTest7 +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=420 +target2.y=340 +target3.height=50 +target3.name=SubTest8 +target3.showInterface=false +target3.type=ClassTarget +target3.width=80 +target3.x=510 +target3.y=340 +target4.height=50 +target4.name=SubTest9 +target4.showInterface=false +target4.type=ClassTarget +target4.width=80 +target4.x=600 +target4.y=340 +target5.height=50 +target5.name=Tester +target5.showInterface=false +target5.type=AbstractTarget +target5.width=80 +target5.x=510 +target5.y=150 +target6.height=50 +target6.name=SubTest2 +target6.showInterface=false +target6.type=ClassTarget +target6.width=80 +target6.x=420 +target6.y=280 +target7.height=50 +target7.name=SubTest3 +target7.showInterface=false +target7.type=ClassTarget +target7.width=80 +target7.x=510 +target7.y=280 +target8.height=50 +target8.name=SubTest4 +target8.showInterface=false +target8.type=ClassTarget +target8.width=80 +target8.x=600 +target8.y=280 +target9.height=50 +target9.name=SubTest5 +target9.showInterface=false +target9.type=ClassTarget +target9.width=80 +target9.x=690 +target9.y=280 diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/README.TXT b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/README.TXT new file mode 100644 index 0000000..6be5ca6 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/README.TXT @@ -0,0 +1,5 @@ +PROJEKTBEZEICHNUNG: Verkettete Liste +PROJEKTZWECK: Implementation einer einfach verketteten Liste +VERSION oder DATUM: 3.10.2020 +WIE IST DAS PROJEKT ZU STARTEN: Testfälle in TesterIterativ bzw. TesterRekursiv ausführen +AUTOR(EN): Rainer Helfrich, ZPG Informatik \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/TesterIterativ.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/TesterIterativ.java new file mode 100644 index 0000000..3c7aaee --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/TesterIterativ.java @@ -0,0 +1,24 @@ +import liste.*; +import tests.*; + +import org.junit.Before; + +/** + * Die Test-Klasse TesterIterativ. + * + * @author Rainer Helfrich + * @version 3.10.2020 + */ +public class TesterIterativ extends Tester +{ + /** + * Setzt das Testgerüst fuer den Test. + * + * Wird vor jeder Testfall-Methode aufgerufen. + */ + @Before + public void setUp() + { + dieListe = new ListeIterativ(); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/TesterRekursiv.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/TesterRekursiv.java new file mode 100644 index 0000000..c22462b --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/TesterRekursiv.java @@ -0,0 +1,24 @@ +import liste.*; +import tests.*; + +import org.junit.Before; + +/** + * Die Test-Klasse TesterIterativ. + * + * @author Rainer Helfrich + * @version 3.10.2020 + */ +public class TesterRekursiv extends Tester +{ + /** + * Setzt das Testgerüst fuer den Test. + * + * Wird vor jeder Testfall-Methode aufgerufen. + */ + @Before + public void setUp() + { + dieListe = new ListeRekursiv(); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/Liste.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/Liste.java new file mode 100644 index 0000000..ddf7963 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/Liste.java @@ -0,0 +1,71 @@ +package liste; + +/** + * Abstrakte Klasse Liste + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public abstract class Liste +{ + /** + * Der erste Knoten der Liste + */ + protected Listenknoten anfang; + + /** + * Gibt zurück, ob die Liste leer ist. + * @return true, wenn die Liste keine Elemente enthält; false sonst + */ + public boolean istLeer() + { + return anfang == null; + } + + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public abstract int laenge(); + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public abstract T getNtenWert(int n); + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public abstract void anhaengen(T val); + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public abstract void einfuegenBei(int index, T val); + + /** + * Gibt die Listenelemente hintereinander auf der Konsole aus. + */ + public void ausgeben() + { + System.out.println(this); + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public abstract boolean enthaelt(T val); + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public abstract void entferneBei(int index); + +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/ListeIterativ.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/ListeIterativ.java new file mode 100644 index 0000000..13e732b --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/ListeIterativ.java @@ -0,0 +1,172 @@ +package liste; + +/** + * Klasse ListeIterativ + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeIterativ extends Liste +{ + /** + * Erzeugt eine neue Liste + */ + public ListeIterativ() + { + anfang = null; + } + + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public int laenge() + { + int len = 0; + Listenknoten k = anfang; + while (k != null) { + k = k.nachfolger; + len++; + } + return len; + } + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public T getNtenWert(int n) + { + Listenknoten k = anfang; + while (k != null) { + if (n == 0) + { + return k.daten; + } + k = k.nachfolger; + n--; + } + return null; + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + Listenknoten neu = new Listenknoten(val, null); + if (anfang == null) + { + anfang = neu; + } + else + { + Listenknoten k = anfang; + while (k.nachfolger != null) + { + k = k.nachfolger; + } + k.nachfolger = neu; + } + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + if (index == 0) + { + anfang = new Listenknoten(val, anfang); + } + else + { + Listenknoten k = anfang; + while (index > 1) + { + if (k == null) + { + return; + } + k = k.nachfolger; + index--; + } + if (k == null) + { + return; + } + k.nachfolger = new Listenknoten(val, k.nachfolger); + } + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public boolean enthaelt(T val) + { + Listenknoten k = anfang; + while (k != null) + { + if (k.daten.equals(val)) + { + return true; + } + k = k.nachfolger; + } + return false; + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + if (anfang == null) + { + return; + } + if (index == 0) + { + anfang = anfang.nachfolger; + } + else + { + Listenknoten tmp = anfang; + while (index > 1 && tmp != null) { + tmp = tmp.nachfolger; + index--; + } + if (tmp != null && tmp.nachfolger != null) + { + tmp.nachfolger = tmp.nachfolger.nachfolger; + } + } + } + + /** + * Gibt die Liste in String-Form aus. + * @return Die String-Repräsentation der Liste + */ + @Override + public String toString() + { + StringBuilder b = new StringBuilder(); + Listenknoten k = anfang; + while(k != null) + { + if (b.length() > 0) + { + b.append(", "); + } + b.append(k.daten); + k = k.nachfolger; + } + return "[ " + b.toString() + " ]"; + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/ListeRekursiv.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/ListeRekursiv.java new file mode 100644 index 0000000..c4ecaa1 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/ListeRekursiv.java @@ -0,0 +1,196 @@ +package liste; + +/** + * Klasse ListeRekursiv + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class ListeRekursiv extends Liste +{ + /** + * Erzeugt eine neue Liste + */ + public ListeRekursiv() + { + anfang = null; + } + + /** + * Gibt die Anzahl der Elemente der Liste zurück + */ + public int laenge() + { + return laenge(anfang); + } + + private int laenge(Listenknoten k) + { + if (k == null) { + return 0; + } + return 1 + laenge(k.nachfolger); + } + + /** + * Gibt den n-ten Wert (0-basierte Zählweise) der Liste zurück. + * @param n Der Index des gewünschten Elements + * @return Den n-ten Wert + */ + public T getNtenWert(int n) + { + return getNtenWert(anfang, n); + } + + private T getNtenWert(Listenknoten k, int n) + { + if (n == 0) { + if (k == null) { + return null; + } + else { + return k.daten; + } + } + return getNtenWert(k.nachfolger, n-1); + } + + /** + * Hängt einen neuen Wert hinten an die Liste an. + * @param val Der anzuhängende Wert + */ + public void anhaengen(T val) + { + if (anfang == null) + { + anfang = new Listenknoten(val, null); + } + else + { + anhaengen(anfang, val); + } + } + + private void anhaengen(Listenknoten k, T val) + { + if (k == null) + { + return; + } + if (k.nachfolger == null) + { + k.nachfolger = new Listenknoten(val, null); + } + else + { + anhaengen(k.nachfolger, val); + } + } + + /** + * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. + * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) + * @param val Der einzufügende Wert + */ + public void einfuegenBei(int index, T val) + { + if (index == 0) + { + anfang = new Listenknoten(val, anfang); + } + else + { + einfuegenBei(anfang, index, val); + } + } + + private void einfuegenBei(Listenknoten k, int index, T val) + { + if (index == 1) + { + k.nachfolger = new Listenknoten(val, k.nachfolger); + } + else + { + einfuegenBei(k.nachfolger, index-1, val); + } + } + + /** + * Gibt zurück, ob ein Wert sich in der Liste befindet + * @param val Der zu suchende Wert + * @return true, wenn der Wert enthalten ist; false sonst + */ + public boolean enthaelt(T val) + { + return enthaelt(anfang, val); + } + + private boolean enthaelt(Listenknoten k, T val) + { + if (k == null) { + return false; + } + if (k.daten.equals(val)) { + return true; + } + return enthaelt(k.nachfolger, val); + } + + /** + * Entfernt das Element, das am gegebenen Index steht, aus der Liste. + * @param index Die Stelle, von der der Wert entfernt werden soll. + */ + public void entferneBei(int index) + { + if (anfang == null) { + return; + } + if (index == 0) { + anfang = anfang.nachfolger; + } + else + { + entferneBei(anfang, index); + } + } + + private void entferneBei(Listenknoten k, int index) + { + if (k != null && k.nachfolger != null) { + if (index == 1) + { + k.nachfolger = k.nachfolger.nachfolger; + } + else + { + entferneBei(k.nachfolger, index-1); + } + } + } + + /** + * Gibt die Liste in String-Form aus. + * @return Die String-Repräsentation der Liste + */ + @Override + public String toString() + { + String ergebnis = "[ "; + if (anfang != null) + { + ergebnis += anfang.daten + toString(anfang.nachfolger); + } + ergebnis += " ]"; + return ergebnis; + } + + private String toString(Listenknoten k) + { + if (k == null) + { + return ""; + } + return ", " + k.daten + toString(k.nachfolger); + } +} \ No newline at end of file diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/Listenknoten.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/Listenknoten.java new file mode 100644 index 0000000..e185d3d --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/Listenknoten.java @@ -0,0 +1,32 @@ +package liste; + +/** + * Klasse Listenknoten + * + * @author Rainer Helfrich + * @version Oktober 2020 + */ +public class Listenknoten +{ + /** + * Der Datenwert des Listenknotens + */ + public T daten; + + /** + * Der Nachfolger des Listenknotens + */ + public Listenknoten nachfolger; + + /** + * Erzeugt einen neuen Listenknoten + * + * @param daten Der Datenwert des Knotens + * @param nachfolger Der Nachfolger des Knotens + */ + public Listenknoten(T daten, Listenknoten nachfolger) + { + this.daten = daten; + this.nachfolger = nachfolger; + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/package.bluej b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/package.bluej new file mode 100644 index 0000000..6b1f21d --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/liste/package.bluej @@ -0,0 +1,57 @@ +#BlueJ package file +dependency1.from=ListeIterativ +dependency1.to=Listenknoten +dependency1.type=UsesDependency +dependency2.from=Liste +dependency2.to=Listenknoten +dependency2.type=UsesDependency +dependency3.from=ListeRekursiv +dependency3.to=Listenknoten +dependency3.type=UsesDependency +objectbench.height=88 +objectbench.width=760 +package.divider.horizontal=0.599476439790576 +package.divider.vertical=0.81 +package.editor.height=398 +package.editor.width=649 +package.editor.x=96 +package.editor.y=221 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=3 +package.numTargets=4 +package.showExtends=true +package.showUses=true +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=ListeIterativ +target1.showInterface=false +target1.type=ClassTarget +target1.width=120 +target1.x=280 +target1.y=240 +target2.height=50 +target2.name=Liste +target2.showInterface=false +target2.type=AbstractTarget +target2.width=80 +target2.x=210 +target2.y=150 +target3.height=50 +target3.name=ListeRekursiv +target3.showInterface=false +target3.type=ClassTarget +target3.width=130 +target3.x=110 +target3.y=240 +target4.height=50 +target4.name=Listenknoten +target4.showInterface=false +target4.type=ClassTarget +target4.width=170 +target4.x=300 +target4.y=70 diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/package.bluej b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/package.bluej new file mode 100644 index 0000000..6f4585e --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/package.bluej @@ -0,0 +1,51 @@ +#BlueJ package file +editor.fx.0.height=739 +editor.fx.0.width=816 +editor.fx.0.x=552 +editor.fx.0.y=100 +objectbench.height=66 +objectbench.width=1000 +package.divider.horizontal=0.6892430278884463 +package.divider.vertical=0.8866459627329193 +package.editor.height=564 +package.editor.width=889 +package.editor.x=0 +package.editor.y=0 +package.frame.height=744 +package.frame.width=1040 +package.numDependencies=0 +package.numTargets=4 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=TesterRekursiv +target1.showInterface=false +target1.type=UnitTestTargetJunit4 +target1.width=120 +target1.x=340 +target1.y=350 +target2.height=62 +target2.name=tests +target2.type=PackageTarget +target2.width=80 +target2.x=240 +target2.y=180 +target3.height=62 +target3.name=liste +target3.type=PackageTarget +target3.width=80 +target3.x=340 +target3.y=180 +target4.height=50 +target4.name=TesterIterativ +target4.showInterface=false +target4.type=UnitTestTargetJunit4 +target4.width=110 +target4.x=210 +target4.y=350 diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest1.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest1.java new file mode 100644 index 0000000..95ab1bf --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest1.java @@ -0,0 +1,2108 @@ +package tests; +import static org.junit.Assert.*; +import liste.*; +/** + * Die Test-Klasse SubTest1. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest1 +{ + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{719}); + + assertFalse("Fehler: Element 84 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(84)); + dieListe.anhaengen(320); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320}); + + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertFalse("Fehler: Element 375 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(375)); + assertFalse("Fehler: Element 691 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(691)); + dieListe.anhaengen(112); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646}); + + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608}); + + assertFalse("Fehler: Element 408 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(408)); + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718}); + + dieListe.anhaengen(726); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726}); + + assertFalse("Fehler: Element 267 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(267)); + assertTrue("Fehler: Element 112 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(241); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241}); + + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297}); + + assertFalse("Fehler: Element 21 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(21)); + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290}); + + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534}); + + assertFalse("Fehler: Element 4 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(4)); + assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718)); + assertFalse("Fehler: Element 710 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(710)); + dieListe.anhaengen(671); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671}); + + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871}); + + dieListe.anhaengen(986); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986}); + + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958}); + + assertTrue("Fehler: Element 534 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(534)); + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + dieListe.anhaengen(98); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98}); + + assertTrue("Fehler: Element 98 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(98)); + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertTrue("Fehler: Element 671 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(671)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertTrue("Fehler: Element 112 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(112)); + assertTrue("Fehler: Element 608 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(608)); + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + assertTrue("Fehler: Element 608 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(608)); + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102}); + + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19}); + + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126}); + + dieListe.anhaengen(771); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771}); + + assertFalse("Fehler: Element 5 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(5)); + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780}); + + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226}); + + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + assertFalse("Fehler: Element 8 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(8)); + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936}); + + assertFalse("Fehler: Element 357 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(357)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + dieListe.anhaengen(986); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986}); + + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335}); + + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254}); + + assertFalse("Fehler: Element 580 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(580)); + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526}); + + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528}); + + assertFalse("Fehler: Element 62 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(62)); + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340}); + + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + assertFalse("Fehler: Element 70 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(70)); + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967}); + + assertTrue("Fehler: Element 731 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(731)); + assertFalse("Fehler: Element 229 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(229)); + assertTrue("Fehler: Element 936 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(936)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + assertFalse("Fehler: Element 764 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(764)); + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83}); + + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + assertFalse("Fehler: Element 544 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(544)); + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308}); + + assertTrue("Fehler: Element 528 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(528)); + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254}); + + assertFalse("Fehler: Element 464 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(464)); + assertFalse("Fehler: Element 468 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(468)); + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.anhaengen(794); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217}); + + assertFalse("Fehler: Element 333 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(333)); + dieListe.anhaengen(210); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210}); + + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65}); + + dieListe.anhaengen(415); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793}); + + assertFalse("Fehler: Element 883 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(883)); + assertFalse("Fehler: Element 463 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(463)); + dieListe.anhaengen(551); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793,551}); + + assertTrue("Fehler: Element 958 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(958)); + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793,551,368}); + + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{719,320,112,646,608,718,726,241,536,297,290,534,671,871,986,958,98,102,19,126,771,780,226,936,986,335,40,441,254,526,820,528,340,731,704,967,83,308,254,794,217,210,65,415,793,551,368,466}); + + assertTrue("Fehler: Element 780 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(780)); + assertFalse("Fehler: Element 850 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(850)); + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(642); + Tester.pruefeListenInhalt(dieListe, new int[]{642}); + + assertFalse("Fehler: Element 158 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(158)); + dieListe.anhaengen(879); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879}); + + dieListe.anhaengen(770); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770}); + + dieListe.anhaengen(181); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181}); + + assertFalse("Fehler: Element 566 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(566)); + assertTrue("Fehler: Element 181 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(181)); + assertFalse("Fehler: Element 70 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(70)); + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25}); + + dieListe.anhaengen(811); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811}); + + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366}); + + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709}); + + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290}); + + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748}); + + dieListe.anhaengen(203); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203}); + + assertFalse("Fehler: Element 683 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(683)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47}); + + dieListe.anhaengen(11); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11}); + + dieListe.anhaengen(483); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483}); + + dieListe.anhaengen(345); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896}); + + dieListe.anhaengen(602); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602}); + + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467}); + + assertFalse("Fehler: Element 609 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(609)); + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254}); + + assertFalse("Fehler: Element 696 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(696)); + assertTrue("Fehler: Element 602 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(602)); + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26}); + + assertTrue("Fehler: Element 483 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(483)); + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123}); + + dieListe.anhaengen(0); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0}); + + dieListe.anhaengen(586); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586}); + + assertFalse("Fehler: Element 487 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(487)); + assertFalse("Fehler: Element 643 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(643)); + dieListe.anhaengen(558); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558}); + + dieListe.anhaengen(132); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132}); + + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322}); + + assertFalse("Fehler: Element 671 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(671)); + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473}); + + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275}); + + assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709)); + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65}); + + assertFalse("Fehler: Element 427 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(427)); + assertTrue("Fehler: Element 25 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(25)); + assertTrue("Fehler: Element 366 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(366)); + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124}); + + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704}); + + dieListe.anhaengen(509); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509}); + + dieListe.anhaengen(489); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329}); + + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626}); + + assertTrue("Fehler: Element 586 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(586)); + dieListe.anhaengen(691); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691}); + + assertTrue("Fehler: Element 285 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(285)); + dieListe.anhaengen(747); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861}); + + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353}); + + assertTrue("Fehler: Element 65 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(65)); + dieListe.anhaengen(32); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32}); + + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402}); + + dieListe.anhaengen(912); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912}); + + dieListe.anhaengen(590); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644}); + + dieListe.anhaengen(13); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263}); + + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480}); + + assertFalse("Fehler: Element 844 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(844)); + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969}); + + dieListe.anhaengen(31); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31}); + + dieListe.anhaengen(183); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183}); + + assertFalse("Fehler: Element 936 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(936)); + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359}); + + dieListe.anhaengen(42); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359,42}); + + assertFalse("Fehler: Element 100 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 770 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(770)); + dieListe.anhaengen(601); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359,42,601}); + + assertTrue("Fehler: Element 183 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(183)); + assertTrue("Fehler: Element 31 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(31)); + assertFalse("Fehler: Element 177 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(177)); + assertTrue("Fehler: Element 181 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(181)); + assertTrue("Fehler: Element 263 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(263)); + assertTrue("Fehler: Element 345 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(345)); + assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709)); + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(239); + Tester.pruefeListenInhalt(dieListe, new int[]{642,879,770,181,25,811,857,366,709,290,361,676,285,748,203,170,47,11,483,345,896,602,467,531,254,26,123,0,586,558,132,322,473,275,65,124,640,704,509,489,329,521,626,691,747,861,353,32,402,912,590,644,13,263,480,969,31,183,949,359,42,601,239}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{877}); + + dieListe.anhaengen(934); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897}); + + dieListe.anhaengen(687); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687}); + + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96}); + + assertFalse("Fehler: Element 716 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(716)); + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936}); + + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531}); + + dieListe.anhaengen(405); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405}); + + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357}); + + assertTrue("Fehler: Element 936 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(936)); + assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198)); + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481}); + + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191}); + + assertFalse("Fehler: Element 160 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(160)); + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543}); + + dieListe.anhaengen(706); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706}); + + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3}); + + dieListe.anhaengen(111); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111}); + + assertFalse("Fehler: Element 450 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(450)); + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + assertFalse("Fehler: Element 319 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(319)); + dieListe.anhaengen(844); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844}); + + assertFalse("Fehler: Element 62 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(62)); + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + dieListe.anhaengen(882); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882}); + + dieListe.anhaengen(847); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847}); + + dieListe.anhaengen(542); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515}); + + assertTrue("Fehler: Element 191 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(191)); + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + dieListe.anhaengen(336); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336}); + + assertFalse("Fehler: Element 857 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(857)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932}); + + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + dieListe.anhaengen(886); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886}); + + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660}); + + assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672)); + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15}); + + assertTrue("Fehler: Element 543 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(543)); + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672}); + + dieListe.anhaengen(525); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525}); + + dieListe.anhaengen(933); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933}); + + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620}); + + assertTrue("Fehler: Element 531 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(531)); + assertFalse("Fehler: Element 816 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(816)); + assertTrue("Fehler: Element 882 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(882)); + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392}); + + assertTrue("Fehler: Element 886 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(886)); + dieListe.anhaengen(41); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41}); + + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314}); + + assertTrue("Fehler: Element 687 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(687)); + assertFalse("Fehler: Element 347 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(347)); + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900}); + + dieListe.anhaengen(794); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896}); + + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480}); + + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490}); + + assertFalse("Fehler: Element 831 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(831)); + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157}); + + assertTrue("Fehler: Element 314 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(314)); + assertTrue("Fehler: Element 886 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(886)); + assertTrue("Fehler: Element 882 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(882)); + assertFalse("Fehler: Element 858 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(858)); + dieListe.anhaengen(48); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359}); + + assertFalse("Fehler: Element 54 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(54)); + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496}); + + assertFalse("Fehler: Element 298 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(298)); + dieListe.anhaengen(231); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231}); + + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + assertFalse("Fehler: Element 369 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(369)); + assertFalse("Fehler: Element 621 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(621)); + assertTrue("Fehler: Element 41 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(41)); + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116}); + + assertFalse("Fehler: Element 67 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(67)); + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108}); + + dieListe.anhaengen(811); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811}); + + assertTrue("Fehler: Element 620 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(620)); + assertFalse("Fehler: Element 344 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(344)); + assertFalse("Fehler: Element 151 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(151)); + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + assertTrue("Fehler: Element 706 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(706)); + dieListe.anhaengen(662); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662}); + + dieListe.anhaengen(929); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929}); + + assertFalse("Fehler: Element 234 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(234)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686}); + + dieListe.anhaengen(657); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657}); + + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905}); + + dieListe.anhaengen(172); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172}); + + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172,25}); + + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172,25,45}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{877,934,897,687,96,936,531,405,357,481,191,543,706,3,111,844,882,847,542,515,336,932,886,660,15,672,525,933,65,620,401,392,41,314,619,900,794,896,480,39,490,157,48,359,496,231,116,108,811,662,929,686,657,905,172,25,45,372}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{312}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertFalse("Fehler: Element 63 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(63)); + assertFalse("Fehler: Element 682 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(682)); + assertFalse("Fehler: Element 97 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(97)); + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361}); + + assertTrue("Fehler: Element 361 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(361)); + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387}); + + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727}); + + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633}); + + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527}); + + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361}); + + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890}); + + assertFalse("Fehler: Element 946 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(946)); + dieListe.anhaengen(742); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742}); + + assertFalse("Fehler: Element 228 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(228)); + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816}); + + dieListe.anhaengen(142); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349}); + + assertFalse("Fehler: Element 909 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(909)); + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + assertTrue("Fehler: Element 742 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(742)); + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366}); + + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675}); + + dieListe.anhaengen(114); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114}); + + assertFalse("Fehler: Element 154 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(154)); + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686}); + + assertFalse("Fehler: Element 724 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(724)); + assertFalse("Fehler: Element 778 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(778)); + assertFalse("Fehler: Element 152 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(152)); + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474}); + + dieListe.anhaengen(220); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220}); + + dieListe.anhaengen(28); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28}); + + dieListe.anhaengen(738); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738}); + + dieListe.anhaengen(987); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987}); + + assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644)); + assertFalse("Fehler: Element 496 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(496)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650}); + + assertTrue("Fehler: Element 650 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(650)); + assertTrue("Fehler: Element 349 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(349)); + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436}); + + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71}); + + assertFalse("Fehler: Element 333 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(333)); + assertFalse("Fehler: Element 563 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(563)); + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259}); + + dieListe.anhaengen(850); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850}); + + assertFalse("Fehler: Element 984 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(984)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + assertFalse("Fehler: Element 634 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(993); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993}); + + assertFalse("Fehler: Element 377 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(377)); + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712}); + + assertFalse("Fehler: Element 130 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(130)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226}); + + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + assertTrue("Fehler: Element 650 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(650)); + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890}); + + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401}); + + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355}); + + assertTrue("Fehler: Element 142 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(142)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191}); + + assertFalse("Fehler: Element 186 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(186)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2}); + + dieListe.anhaengen(88); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88}); + + assertTrue("Fehler: Element 738 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(738)); + assertFalse("Fehler: Element 614 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(614)); + assertTrue("Fehler: Element 361 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(361)); + assertFalse("Fehler: Element 58 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(58)); + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699}); + + assertFalse("Fehler: Element 813 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(813)); + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117}); + + assertTrue("Fehler: Element 71 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(71)); + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + assertFalse("Fehler: Element 40 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(40)); + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869}); + + dieListe.anhaengen(590); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590}); + + dieListe.anhaengen(161); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161}); + + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161,740}); + + assertFalse("Fehler: Element 610 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(610)); + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161,740,344}); + + dieListe.anhaengen(381); + Tester.pruefeListenInhalt(dieListe, new int[]{312,725,637,576,361,387,66,727,633,527,361,890,742,816,142,349,366,675,114,686,474,220,28,738,987,650,436,71,259,850,993,712,226,890,401,355,191,2,88,699,117,869,590,161,740,344,381}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(317); + Tester.pruefeListenInhalt(dieListe, new int[]{317}); + + assertTrue("Fehler: Element 317 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(317)); + dieListe.anhaengen(256); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256}); + + assertFalse("Fehler: Element 698 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(698)); + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255}); + + assertFalse("Fehler: Element 131 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(131)); + assertFalse("Fehler: Element 109 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(109)); + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3}); + + dieListe.anhaengen(229); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229}); + + dieListe.anhaengen(764); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764}); + + dieListe.anhaengen(67); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67}); + + dieListe.anhaengen(231); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231}); + + assertTrue("Fehler: Element 764 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(764)); + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312}); + + dieListe.anhaengen(517); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517}); + + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969}); + + assertFalse("Fehler: Element 164 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(164)); + dieListe.anhaengen(621); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621}); + + assertFalse("Fehler: Element 267 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(267)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + assertFalse("Fehler: Element 369 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(369)); + assertFalse("Fehler: Element 749 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(749)); + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + assertTrue("Fehler: Element 517 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(517)); + dieListe.anhaengen(656); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656}); + + dieListe.anhaengen(279); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279}); + + assertFalse("Fehler: Element 400 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(400)); + assertTrue("Fehler: Element 305 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(305)); + assertTrue("Fehler: Element 256 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(256)); + assertFalse("Fehler: Element 958 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(958)); + assertFalse("Fehler: Element 88 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(88)); + assertFalse("Fehler: Element 922 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(922)); + dieListe.anhaengen(760); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286}); + + assertFalse("Fehler: Element 185 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(185)); + dieListe.anhaengen(901); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901}); + + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780}); + + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertTrue("Fehler: Element 286 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(286)); + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949}); + + dieListe.anhaengen(629); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629}); + + dieListe.anhaengen(0); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0}); + + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156)); + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178}); + + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487}); + + assertTrue("Fehler: Element 656 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(656)); + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + assertTrue("Fehler: Element 0 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(0)); + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + assertFalse("Fehler: Element 432 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(432)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736}); + + dieListe.anhaengen(59); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59}); + + dieListe.anhaengen(427); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427}); + + dieListe.anhaengen(327); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327}); + + assertTrue("Fehler: Element 279 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(279)); + assertFalse("Fehler: Element 676 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(676)); + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388}); + + dieListe.anhaengen(9); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225)); + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521}); + + dieListe.anhaengen(206); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206}); + + assertFalse("Fehler: Element 565 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(565)); + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411}); + + assertTrue("Fehler: Element 621 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(621)); + dieListe.anhaengen(156); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156}); + + assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231)); + dieListe.anhaengen(610); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610}); + + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + assertFalse("Fehler: Element 881 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(881)); + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767}); + + assertTrue("Fehler: Element 764 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(764)); + dieListe.anhaengen(592); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592}); + + assertFalse("Fehler: Element 197 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(197)); + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95}); + + assertTrue("Fehler: Element 3 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(3)); + dieListe.anhaengen(636); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264}); + + assertTrue("Fehler: Element 156 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(156)); + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852}); + + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653}); + + dieListe.anhaengen(224); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224}); + + assertTrue("Fehler: Element 0 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(0)); + assertTrue("Fehler: Element 231 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(231)); + dieListe.anhaengen(398); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224,398}); + + assertFalse("Fehler: Element 729 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(729)); + dieListe.anhaengen(754); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224,398,754}); + + assertTrue("Fehler: Element 95 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(95)); + assertTrue("Fehler: Element 901 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(901)); + dieListe.anhaengen(237); + Tester.pruefeListenInhalt(dieListe, new int[]{317,256,255,3,229,764,67,231,312,517,969,621,688,305,656,279,760,286,901,780,949,629,0,178,487,225,736,59,427,327,388,9,521,206,411,156,610,767,592,95,636,264,914,411,852,653,224,398,754,237}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(800); + Tester.pruefeListenInhalt(dieListe, new int[]{800}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254}); + + assertFalse("Fehler: Element 255 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(255)); + assertTrue("Fehler: Element 254 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(254)); + dieListe.anhaengen(638); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638}); + + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189}); + + assertFalse("Fehler: Element 426 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(426)); + dieListe.anhaengen(571); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571}); + + assertFalse("Fehler: Element 339 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(339)); + assertTrue("Fehler: Element 437 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413}); + + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116}); + + dieListe.anhaengen(741); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741}); + + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870}); + + dieListe.anhaengen(323); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.anhaengen(859); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859}); + + dieListe.anhaengen(847); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847}); + + assertFalse("Fehler: Element 941 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(941)); + dieListe.anhaengen(759); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759}); + + assertFalse("Fehler: Element 914 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(914)); + assertTrue("Fehler: Element 437 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(218); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189}); + + assertTrue("Fehler: Element 218 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(218)); + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862}); + + dieListe.anhaengen(540); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540}); + + dieListe.anhaengen(580); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + assertTrue("Fehler: Element 465 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(465)); + assertFalse("Fehler: Element 813 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(813)); + assertFalse("Fehler: Element 103 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(103)); + dieListe.anhaengen(370); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370}); + + assertTrue("Fehler: Element 254 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(254)); + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293}); + + assertFalse("Fehler: Element 618 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(618)); + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(291); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291}); + + assertTrue("Fehler: Element 218 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(218)); + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786}); + + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536}); + + dieListe.anhaengen(824); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824}); + + assertFalse("Fehler: Element 215 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(215)); + assertFalse("Fehler: Element 283 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(283)); + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622}); + + assertFalse("Fehler: Element 22 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(22)); + assertFalse("Fehler: Element 954 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(954)); + dieListe.anhaengen(91); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91}); + + dieListe.anhaengen(422); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422}); + + dieListe.anhaengen(301); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301}); + + assertFalse("Fehler: Element 614 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(614)); + assertTrue("Fehler: Element 824 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(824)); + dieListe.anhaengen(636); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636}); + + assertTrue("Fehler: Element 847 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(847)); + assertTrue("Fehler: Element 26 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(26)); + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.anhaengen(661); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637}); + + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700}); + + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651}); + + assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239)); + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299}); + + dieListe.anhaengen(714); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714}); + + dieListe.anhaengen(8); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8}); + + assertTrue("Fehler: Element 580 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(580)); + assertTrue("Fehler: Element 323 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(323)); + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154}); + + assertTrue("Fehler: Element 862 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(862)); + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749}); + + assertTrue("Fehler: Element 465 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(465)); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923}); + + assertTrue("Fehler: Element 700 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(700)); + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603}); + + dieListe.anhaengen(252); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252}); + + assertFalse("Fehler: Element 488 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(488)); + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869}); + + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); + assertTrue("Fehler: Element 749 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(749)); + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.anhaengen(158); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + assertFalse("Fehler: Element 416 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(416)); + dieListe.anhaengen(459); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158,459}); + + assertFalse("Fehler: Element 856 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(856)); + dieListe.anhaengen(58); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158,459,58}); + + dieListe.anhaengen(230); + Tester.pruefeListenInhalt(dieListe, new int[]{800,437,254,638,189,571,975,465,413,116,741,870,323,859,847,759,218,189,26,862,540,580,370,293,291,786,536,824,622,91,422,301,636,661,637,700,651,22,105,299,714,8,154,749,440,923,603,252,869,158,459,58,230}); + + assertFalse("Fehler: Element 168 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(168)); + assertTrue("Fehler: Element 540 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(540)); + assertTrue("Fehler: Element 536 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(536)); + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(16); + Tester.pruefeListenInhalt(dieListe, new int[]{16}); + + assertFalse("Fehler: Element 785 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(785)); + dieListe.anhaengen(607); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607}); + + assertFalse("Fehler: Element 61 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(61)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(399); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399}); + + assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + assertTrue("Fehler: Element 607 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(607)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219}); + + assertTrue("Fehler: Element 219 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(219)); + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96}); + + assertFalse("Fehler: Element 746 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(746)); + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608}); + + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + dieListe.anhaengen(831); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831}); + + dieListe.anhaengen(53); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53}); + + dieListe.anhaengen(379); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379}); + + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280}); + + dieListe.anhaengen(802); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527}); + + assertFalse("Fehler: Element 917 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(917)); + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333}); + + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606}); + + dieListe.anhaengen(713); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713}); + + assertFalse("Fehler: Element 434 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(434)); + assertFalse("Fehler: Element 794 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(794)); + dieListe.anhaengen(724); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724}); + + dieListe.anhaengen(244); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244}); + + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6}); + + assertTrue("Fehler: Element 6 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(6)); + assertTrue("Fehler: Element 606 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(606)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertTrue("Fehler: Element 608 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(608)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(472); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472}); + + dieListe.anhaengen(188); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637}); + + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 606 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(606)); + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + dieListe.anhaengen(833); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833}); + + dieListe.anhaengen(886); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886}); + + dieListe.anhaengen(895); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576}); + + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + dieListe.anhaengen(224); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224}); + + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2}); + + assertFalse("Fehler: Element 868 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(868)); + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + assertFalse("Fehler: Element 932 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(932)); + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909}); + + assertFalse("Fehler: Element 519 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(519)); + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + dieListe.anhaengen(456); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456}); + + dieListe.anhaengen(588); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588}); + + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + dieListe.anhaengen(692); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692}); + + assertFalse("Fehler: Element 43 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(43)); + assertFalse("Fehler: Element 880 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(880)); + dieListe.anhaengen(342); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342}); + + assertFalse("Fehler: Element 795 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(795)); + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95}); + + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + assertFalse("Fehler: Element 387 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(387)); + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.anhaengen(386); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386}); + + assertFalse("Fehler: Element 846 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(846)); + dieListe.anhaengen(398); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398}); + + assertFalse("Fehler: Element 665 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(665)); + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251}); + + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535}); + + dieListe.anhaengen(856); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856}); + + dieListe.anhaengen(602); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602}); + + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921}); + + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645}); + + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertFalse("Fehler: Element 783 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(783)); + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82}); + + dieListe.anhaengen(971); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971,245}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertFalse("Fehler: Element 43 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(43)); + assertFalse("Fehler: Element 653 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(653)); + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971,245,955}); + + dieListe.anhaengen(978); + Tester.pruefeListenInhalt(dieListe, new int[]{16,607,583,399,490,219,96,608,831,53,379,280,802,634,527,333,606,713,724,244,6,472,188,637,833,886,895,576,2,224,2,909,456,588,692,342,95,386,398,251,535,856,602,921,645,82,971,245,955,978}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{557}); + + assertFalse("Fehler: Element 184 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(184)); + dieListe.anhaengen(265); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265}); + + assertFalse("Fehler: Element 357 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(357)); + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366}); + + assertFalse("Fehler: Element 596 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(596)); + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743}); + + dieListe.anhaengen(893); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893}); + + dieListe.anhaengen(423); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423}); + + dieListe.anhaengen(29); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29}); + + assertTrue("Fehler: Element 423 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(423)); + assertFalse("Fehler: Element 98 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(98)); + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957}); + + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + dieListe.anhaengen(408); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + dieListe.anhaengen(41); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41}); + + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653}); + + assertFalse("Fehler: Element 648 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(648)); + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402}); + + assertTrue("Fehler: Element 265 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(265)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932}); + + assertTrue("Fehler: Element 82 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(82)); + assertFalse("Fehler: Element 282 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(282)); + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727}); + + assertFalse("Fehler: Element 405 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(405)); + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(393); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393}); + + assertFalse("Fehler: Element 21 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(21)); + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19}); + + assertTrue("Fehler: Element 957 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(957)); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547}); + + assertFalse("Fehler: Element 33 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(33)); + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152}); + + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6}); + + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531}); + + assertFalse("Fehler: Element 543 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(543)); + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + assertTrue("Fehler: Element 932 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(932)); + dieListe.anhaengen(444); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444}); + + dieListe.anhaengen(70); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70}); + + assertFalse("Fehler: Element 315 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(315)); + assertFalse("Fehler: Element 363 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(363)); + dieListe.anhaengen(464); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464}); + + dieListe.anhaengen(855); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855}); + + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40}); + + dieListe.anhaengen(716); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716}); + + dieListe.anhaengen(584); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584}); + + assertFalse("Fehler: Element 262 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(262)); + assertTrue("Fehler: Element 704 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(704)); + assertTrue("Fehler: Element 70 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(70)); + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845}); + + assertTrue("Fehler: Element 494 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(494)); + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196}); + + dieListe.anhaengen(261); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261}); + + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178}); + + dieListe.anhaengen(232); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232}); + + dieListe.anhaengen(163); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163}); + + dieListe.anhaengen(946); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946}); + + assertTrue("Fehler: Element 946 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(946)); + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(177); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177}); + + assertFalse("Fehler: Element 633 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(633)); + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434}); + + assertTrue("Fehler: Element 177 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(177)); + dieListe.anhaengen(614); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186}); + + assertFalse("Fehler: Element 339 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(339)); + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178}); + + assertTrue("Fehler: Element 82 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(82)); + dieListe.anhaengen(242); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242}); + + dieListe.anhaengen(808); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808}); + + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473}); + + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623}); + + dieListe.anhaengen(673); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673}); + + assertTrue("Fehler: Element 531 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(531)); + assertFalse("Fehler: Element 447 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(447)); + assertFalse("Fehler: Element 147 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(147)); + dieListe.anhaengen(179); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179}); + + dieListe.anhaengen(52); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52}); + + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.anhaengen(944); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944}); + + dieListe.anhaengen(88); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944,88}); + + dieListe.anhaengen(903); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944,88,903}); + + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{557,265,82,217,644,366,743,893,423,29,704,957,816,920,408,41,653,402,932,727,393,19,547,494,152,6,531,306,444,70,464,855,40,716,584,868,845,196,261,178,232,163,946,177,434,614,743,186,178,242,808,473,623,673,179,52,944,88,903,866}); + + assertFalse("Fehler: Element 728 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(728)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{975}); + + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395}); + + dieListe.anhaengen(147); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147}); + + dieListe.anhaengen(806); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806}); + + dieListe.anhaengen(192); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192}); + + dieListe.anhaengen(107); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107}); + + assertFalse("Fehler: Element 168 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(168)); + dieListe.anhaengen(209); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209}); + + assertFalse("Fehler: Element 915 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(915)); + assertFalse("Fehler: Element 250 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(250)); + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + assertTrue("Fehler: Element 147 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(147)); + dieListe.anhaengen(821); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821}); + + assertFalse("Fehler: Element 990 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(990)); + assertTrue("Fehler: Element 806 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(806)); + dieListe.anhaengen(572); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572}); + + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711}); + + dieListe.anhaengen(779); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779}); + + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333}); + + dieListe.anhaengen(663); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340}); + + dieListe.anhaengen(294); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294}); + + assertFalse("Fehler: Element 109 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(109)); + assertFalse("Fehler: Element 444 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(444)); + assertFalse("Fehler: Element 280 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(280)); + assertFalse("Fehler: Element 11 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(11)); + assertFalse("Fehler: Element 614 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(614)); + assertFalse("Fehler: Element 470 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(470)); + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931}); + + dieListe.anhaengen(76); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76}); + + assertFalse("Fehler: Element 64 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606}); + + assertFalse("Fehler: Element 371 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(371)); + dieListe.anhaengen(331); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331}); + + assertTrue("Fehler: Element 331 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(331)); + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271}); + + assertFalse("Fehler: Element 7 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(7)); + assertTrue("Fehler: Element 821 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(821)); + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793}); + + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + assertFalse("Fehler: Element 547 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(547)); + assertFalse("Fehler: Element 114 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(114)); + assertTrue("Fehler: Element 663 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(663)); + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570}); + + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15}); + + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871}); + + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631}); + + assertFalse("Fehler: Element 490 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(490)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328}); + + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362}); + + dieListe.anhaengen(46); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46}); + + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276}); + + assertFalse("Fehler: Element 738 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(738)); + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertFalse("Fehler: Element 245 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(245)); + assertFalse("Fehler: Element 314 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(314)); + assertTrue("Fehler: Element 631 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(631)); + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318}); + + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920}); + + assertFalse("Fehler: Element 861 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(861)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932}); + + assertTrue("Fehler: Element 333 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(333)); + assertTrue("Fehler: Element 46 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(46)); + assertTrue("Fehler: Element 362 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(362)); + assertTrue("Fehler: Element 46 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(46)); + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723}); + + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + assertFalse("Fehler: Element 199 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(199)); + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890}); + + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909}); + + dieListe.anhaengen(399); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399}); + + dieListe.anhaengen(143); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143}); + + assertFalse("Fehler: Element 605 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(605)); + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297}); + + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788}); + + dieListe.anhaengen(407); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407}); + + assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15)); + assertFalse("Fehler: Element 747 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(747)); + assertFalse("Fehler: Element 235 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(235)); + assertTrue("Fehler: Element 572 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(572)); + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + assertFalse("Fehler: Element 620 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(620)); + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439}); + + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920}); + + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905}); + + assertTrue("Fehler: Element 209 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(209)); + assertTrue("Fehler: Element 143 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(143)); + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905,480}); + + dieListe.anhaengen(327); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905,480,327}); + + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{975,395,147,806,192,107,209,821,572,711,779,333,663,340,294,931,76,606,331,271,793,570,15,871,631,328,362,46,259,276,318,21,920,932,723,362,890,968,909,399,143,297,788,407,439,920,905,480,327,124}); + + assertTrue("Fehler: Element 723 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(723)); + assertTrue("Fehler: Element 362 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(362)); + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{117}); + + assertFalse("Fehler: Element 732 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(732)); + assertTrue("Fehler: Element 117 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(117)); + assertTrue("Fehler: Element 117 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(117)); + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853}); + + assertFalse("Fehler: Element 384 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(384)); + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622}); + + dieListe.anhaengen(500); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500}); + + dieListe.anhaengen(284); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284}); + + dieListe.anhaengen(81); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81}); + + assertFalse("Fehler: Element 174 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(174)); + assertFalse("Fehler: Element 814 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(814)); + dieListe.anhaengen(278); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278}); + + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507}); + + dieListe.anhaengen(701); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701}); + + assertTrue("Fehler: Element 622 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(622)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709}); + + dieListe.anhaengen(756); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756}); + + assertFalse("Fehler: Element 387 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(387)); + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870}); + + assertFalse("Fehler: Element 203 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(203)); + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931}); + + assertFalse("Fehler: Element 448 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(448)); + assertFalse("Fehler: Element 373 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(373)); + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494}); + + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543}); + + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627}); + + dieListe.anhaengen(304); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304}); + + assertTrue("Fehler: Element 853 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(853)); + assertTrue("Fehler: Element 870 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(870)); + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297}); + + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788}); + + dieListe.anhaengen(55); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55}); + + assertFalse("Fehler: Element 544 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(544)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + dieListe.anhaengen(159); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159}); + + assertTrue("Fehler: Element 701 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(701)); + assertFalse("Fehler: Element 859 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(859)); + assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313)); + dieListe.anhaengen(248); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248}); + + assertFalse("Fehler: Element 739 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(739)); + dieListe.anhaengen(756); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756}); + + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383}); + + assertFalse("Fehler: Element 902 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(902)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + dieListe.anhaengen(375); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375}); + + assertTrue("Fehler: Element 55 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(55)); + assertFalse("Fehler: Element 422 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(422)); + assertTrue("Fehler: Element 452 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(452)); + dieListe.anhaengen(566); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566}); + + assertTrue("Fehler: Element 248 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(248)); + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757}); + + assertTrue("Fehler: Element 375 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(375)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + assertFalse("Fehler: Element 987 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 870 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(870)); + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470}); + + dieListe.anhaengen(385); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385}); + + dieListe.anhaengen(10); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10}); + + assertFalse("Fehler: Element 666 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(666)); + assertTrue("Fehler: Element 55 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(55)); + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417}); + + assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311)); + dieListe.anhaengen(200); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200}); + + assertTrue("Fehler: Element 10 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(10)); + dieListe.anhaengen(601); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601}); + + assertFalse("Fehler: Element 582 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(582)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709}); + + assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157)); + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + assertFalse("Fehler: Element 900 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(900)); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547}); + + dieListe.anhaengen(282); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282}); + + assertFalse("Fehler: Element 810 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(810)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + dieListe.anhaengen(433); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433}); + + dieListe.anhaengen(454); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454}); + + assertFalse("Fehler: Element 185 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(185)); + assertTrue("Fehler: Element 55 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(55)); + assertTrue("Fehler: Element 756 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(756)); + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640}); + + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640,480}); + + assertFalse("Fehler: Element 473 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(473)); + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640,480,355}); + + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + assertFalse("Fehler: Element 568 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(568)); + assertFalse("Fehler: Element 591 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(591)); + dieListe.anhaengen(375); + Tester.pruefeListenInhalt(dieListe, new int[]{117,452,853,622,500,284,81,278,401,507,701,709,756,870,931,494,543,627,304,972,679,297,788,55,159,248,756,383,375,566,15,757,470,385,10,337,490,417,200,601,709,547,282,433,454,640,480,355,375}); + +} +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest10.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest10.java new file mode 100644 index 0000000..70acc13 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest10.java @@ -0,0 +1,2733 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest10. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest10 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(184); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + dieListe.anhaengen(90); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 90}); + + assertTrue("Fehler: Element 90 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(90)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + assertFalse("Fehler: Element 332 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(332)); + dieListe.anhaengen(911); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911}); + + dieListe.anhaengen(418); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 418}); + + dieListe.anhaengen(522); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 418, 522}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 911, 522}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 522}); + + assertFalse("Fehler: Element 952 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(952)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + assertTrue("Fehler: Element 184 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(184)); + dieListe.einfuegenBei(1, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362, 108}); + + assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265)); + assertFalse("Fehler: Element 640 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(640)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362}); + + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 362, 308}); + + dieListe.einfuegenBei(1, 627); + Tester.pruefeListenInhalt(dieListe, new int[]{184, 627, 362, 308}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{603}); + + assertTrue("Fehler: Element 603 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(603)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(90); + Tester.pruefeListenInhalt(dieListe, new int[]{90}); + + assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(182); + Tester.pruefeListenInhalt(dieListe, new int[]{182}); + + dieListe.einfuegenBei(1, 371); + Tester.pruefeListenInhalt(dieListe, new int[]{182, 371}); + + dieListe.einfuegenBei(2, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{182, 371, 525}); + + dieListe.einfuegenBei(3, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{182, 371, 525, 380}); + + assertFalse("Fehler: Element 810 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(810)); + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{371, 525, 380}); + + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 380}); + + assertFalse("Fehler: Element 253 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(253)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{380}); + + dieListe.einfuegenBei(0, 942); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 380}); + + dieListe.anhaengen(848); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 380, 848}); + + assertTrue("Fehler: Element 380 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(380)); + assertFalse("Fehler: Element 620 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(620)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848}); + + dieListe.einfuegenBei(2, 914); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 914}); + + assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914)); + assertTrue("Fehler: Element 848 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(848)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848}); + + assertTrue("Fehler: Element 848 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(848)); + dieListe.einfuegenBei(2, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 311}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{942, 848, 311, 7}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 863); + Tester.pruefeListenInhalt(dieListe, new int[]{863}); + + dieListe.einfuegenBei(1, 206); + Tester.pruefeListenInhalt(dieListe, new int[]{863, 206}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{863}); + + dieListe.anhaengen(360); + Tester.pruefeListenInhalt(dieListe, new int[]{863, 360}); + + dieListe.einfuegenBei(0, 860); + Tester.pruefeListenInhalt(dieListe, new int[]{860, 863, 360}); + + assertTrue("Fehler: Element 863 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(863)); + assertTrue("Fehler: Element 863 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(863)); + assertFalse("Fehler: Element 433 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(433)); + dieListe.anhaengen(230); + Tester.pruefeListenInhalt(dieListe, new int[]{860, 863, 360, 230}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{264}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 820); + Tester.pruefeListenInhalt(dieListe, new int[]{820}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 796); + Tester.pruefeListenInhalt(dieListe, new int[]{796}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 860}); + + assertTrue("Fehler: Element 796 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(796)); + dieListe.einfuegenBei(1, 141); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 860}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141}); + + dieListe.einfuegenBei(2, 703); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703}); + + dieListe.anhaengen(376); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703, 376}); + + dieListe.einfuegenBei(2, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 536, 703, 376}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 141, 703, 376}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(587); + Tester.pruefeListenInhalt(dieListe, new int[]{587}); + + dieListe.einfuegenBei(1, 240); + Tester.pruefeListenInhalt(dieListe, new int[]{587, 240}); + + dieListe.einfuegenBei(0, 449); + Tester.pruefeListenInhalt(dieListe, new int[]{449, 587, 240}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{587, 240}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{587}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 826); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + dieListe.einfuegenBei(1, 361); + Tester.pruefeListenInhalt(dieListe, new int[]{826, 361}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + assertTrue("Fehler: Element 826 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(826)); + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{826, 100}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{23}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{296}); + + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 822}); + + dieListe.einfuegenBei(2, 149); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 822, 149}); + + dieListe.anhaengen(934); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 822, 149, 934}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 934}); + + dieListe.einfuegenBei(2, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 281, 934}); + + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 149, 281, 934, 750}); + + dieListe.einfuegenBei(0, 594); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 296, 149, 281, 934, 750}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 296, 149, 281, 934, 750, 787}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{794}); + + dieListe.einfuegenBei(0, 18); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 794}); + + dieListe.einfuegenBei(1, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 546, 794}); + + assertTrue("Fehler: Element 546 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(546)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 794}); + + dieListe.anhaengen(984); + Tester.pruefeListenInhalt(dieListe, new int[]{18, 794, 984}); + + assertFalse("Fehler: Element 957 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(957)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{794, 984}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{794}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{572}); + + dieListe.einfuegenBei(1, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599}); + + dieListe.anhaengen(284); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + assertFalse("Fehler: Element 817 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(817)); + assertTrue("Fehler: Element 284 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(284)); + dieListe.einfuegenBei(2, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 78, 284}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284, 529}); + + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + assertFalse("Fehler: Element 540 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(540)); + dieListe.einfuegenBei(1, 9); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 9, 599, 284}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 284, 469}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 599, 469}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469}); + + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 39}); + + dieListe.anhaengen(880); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 39, 880}); + + assertTrue("Fehler: Element 39 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(39)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 469, 880}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 880}); + + dieListe.einfuegenBei(1, 264); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 880}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264}); + + assertFalse("Fehler: Element 225 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(225)); + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.einfuegenBei(2, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 686}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264}); + + dieListe.einfuegenBei(2, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884}); + + dieListe.anhaengen(721); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884, 721}); + + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + dieListe.anhaengen(307); + Tester.pruefeListenInhalt(dieListe, new int[]{599, 264, 884, 721, 307}); + + dieListe.einfuegenBei(0, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 264, 884, 721, 307}); + + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 264, 721, 307}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 599, 721, 307}); + + dieListe.einfuegenBei(1, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 82, 599, 721, 307}); + + dieListe.anhaengen(531); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 82, 599, 721, 307, 531}); + + dieListe.einfuegenBei(1, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 686, 82, 599, 721, 307, 531}); + + assertTrue("Fehler: Element 307 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(307)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 407); + Tester.pruefeListenInhalt(dieListe, new int[]{407}); + + assertFalse("Fehler: Element 254 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(254)); + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 25}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 25, 262}); + + assertFalse("Fehler: Element 521 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(521)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 25, 262, 736}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 262, 736}); + + assertFalse("Fehler: Element 346 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(346)); + dieListe.einfuegenBei(1, 149); + Tester.pruefeListenInhalt(dieListe, new int[]{407, 149, 262, 736}); + + assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736, 502}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 262, 736}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{372}); + + assertTrue("Fehler: Element 372 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(372)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(999); + Tester.pruefeListenInhalt(dieListe, new int[]{999}); + + dieListe.anhaengen(790); + Tester.pruefeListenInhalt(dieListe, new int[]{999, 790}); + + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.einfuegenBei(0, 524); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 999, 790}); + + assertFalse("Fehler: Element 387 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(387)); + dieListe.einfuegenBei(2, 13); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 999, 13, 790}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 13, 790}); + + dieListe.einfuegenBei(1, 309); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 309, 13, 790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{309, 13, 790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{13, 790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{790}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{245}); + + dieListe.einfuegenBei(0, 517); + Tester.pruefeListenInhalt(dieListe, new int[]{517, 245}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{245}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 907); + Tester.pruefeListenInhalt(dieListe, new int[]{907}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(898); + Tester.pruefeListenInhalt(dieListe, new int[]{898}); + + assertTrue("Fehler: Element 898 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(898)); + dieListe.einfuegenBei(0, 296); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 898}); + + assertFalse("Fehler: Element 677 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(677)); + assertFalse("Fehler: Element 621 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(621)); + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{296, 898, 777}); + + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 140); + Tester.pruefeListenInhalt(dieListe, new int[]{140}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(62); + Tester.pruefeListenInhalt(dieListe, new int[]{62}); + + assertTrue("Fehler: Element 62 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(62)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{247}); + + assertFalse("Fehler: Element 494 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(494)); + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{247, 425}); + + assertTrue("Fehler: Element 247 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(247)); + assertTrue("Fehler: Element 425 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(425)); + assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{247}); + + dieListe.anhaengen(552); + Tester.pruefeListenInhalt(dieListe, new int[]{247, 552}); + + assertFalse("Fehler: Element 295 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(295)); + assertFalse("Fehler: Element 259 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(259)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{247}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 395); + Tester.pruefeListenInhalt(dieListe, new int[]{395}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 387}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{395}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 403}); + + assertTrue("Fehler: Element 403 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(403)); + assertTrue("Fehler: Element 403 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(403)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{395}); + + dieListe.einfuegenBei(0, 223); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 395}); + + dieListe.einfuegenBei(2, 830); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 395, 830}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830}); + + assertFalse("Fehler: Element 504 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(504)); + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277}); + + assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277)); + assertTrue("Fehler: Element 830 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(830)); + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292}); + + dieListe.einfuegenBei(4, 653); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 653}); + + dieListe.einfuegenBei(4, 458); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653}); + + dieListe.anhaengen(839); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839}); + + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839, 100}); + + dieListe.anhaengen(73); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 830, 277, 292, 458, 653, 839, 100, 73}); + + assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110}); + + dieListe.einfuegenBei(9, 116); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110, 116}); + + dieListe.einfuegenBei(9, 332); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 277, 292, 458, 653, 839, 100, 73, 110, 332, 116}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(927); + Tester.pruefeListenInhalt(dieListe, new int[]{927}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 526}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{526}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{837}); + + assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311)); + dieListe.einfuegenBei(0, 135); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 837}); + + dieListe.einfuegenBei(1, 472); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 837}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472}); + + dieListe.anhaengen(811); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811}); + + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + dieListe.anhaengen(775); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775}); + + dieListe.einfuegenBei(4, 895); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775, 895}); + + dieListe.einfuegenBei(4, 408); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 472, 811, 775, 408, 895}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{366}); + + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 786}); + + assertFalse("Fehler: Element 734 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(734)); + dieListe.anhaengen(598); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 786, 598}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 598}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{598}); + + dieListe.anhaengen(668); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 668}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{668}); + + dieListe.einfuegenBei(1, 344); + Tester.pruefeListenInhalt(dieListe, new int[]{668, 344}); + + assertTrue("Fehler: Element 344 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(344)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{668}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{620}); + + assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157)); + dieListe.anhaengen(389); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 389}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{620}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 72); + Tester.pruefeListenInhalt(dieListe, new int[]{72}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{152}); + + dieListe.einfuegenBei(0, 101); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152}); + + dieListe.anhaengen(753); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753}); + + dieListe.anhaengen(695); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753, 695}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753}); + + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 152, 753, 121}); + + dieListe.einfuegenBei(1, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 121}); + + dieListe.einfuegenBei(4, 47); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 47, 121}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 121}); + + dieListe.einfuegenBei(4, 453); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121}); + + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121, 349}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 152, 753, 453, 121, 349, 634}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 453, 121, 349, 634}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.einfuegenBei(3, 820); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634, 515}); + + dieListe.anhaengen(715); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 349, 634, 515, 715}); + + dieListe.einfuegenBei(6, 378); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 753, 820, 453, 121, 378, 349, 634, 515, 715}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 453, 121, 378, 349, 634, 515, 715}); + + dieListe.einfuegenBei(6, 73); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 453, 121, 378, 73, 349, 634, 515, 715}); + + dieListe.einfuegenBei(3, 0); + Tester.pruefeListenInhalt(dieListe, new int[]{101, 220, 820, 0, 453, 121, 378, 73, 349, 634, 515, 715}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{434}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{434, 157}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{434, 157, 387}); + + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{434, 157, 387, 306}); + + assertTrue("Fehler: Element 387 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(387)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306}); + + assertFalse("Fehler: Element 922 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(922)); + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306, 625}); + + dieListe.einfuegenBei(3, 751); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 387, 306, 751, 625}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 625}); + + assertFalse("Fehler: Element 498 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(498)); + assertFalse("Fehler: Element 782 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(782)); + dieListe.anhaengen(438); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 625, 438}); + + dieListe.einfuegenBei(3, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 758, 625, 438}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 751, 758, 625}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 306, 758, 625}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 625}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758}); + + dieListe.anhaengen(584); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 584}); + + dieListe.anhaengen(616); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 758, 584, 616}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616}); + + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.einfuegenBei(3, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652}); + + assertFalse("Fehler: Element 157 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(157)); + assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644)); + assertFalse("Fehler: Element 301 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(301)); + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660}); + + dieListe.einfuegenBei(5, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660, 880}); + + assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407)); + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 616, 652, 660, 880, 711}); + + dieListe.einfuegenBei(2, 176); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711}); + + dieListe.anhaengen(803); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711, 803}); + + assertTrue("Fehler: Element 660 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(660)); + assertFalse("Fehler: Element 573 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(573)); + dieListe.anhaengen(63); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 652, 660, 880, 711, 803, 63}); + + dieListe.einfuegenBei(4, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{758, 584, 176, 616, 525, 652, 660, 880, 711, 803, 63}); + + dieListe.einfuegenBei(0, 50); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 880, 711, 803, 63}); + + assertTrue("Fehler: Element 711 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(711)); + dieListe.einfuegenBei(8, 695); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63}); + + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605}); + + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983}); + + assertTrue("Fehler: Element 880 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(880)); + assertFalse("Fehler: Element 224 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(224)); + dieListe.einfuegenBei(0, 535); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983}); + + assertFalse("Fehler: Element 14 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(14)); + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.anhaengen(800); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983, 800}); + + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 983, 800, 699}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 652, 660, 695, 880, 711, 803, 63, 605, 800, 699}); + + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964}); + + assertFalse("Fehler: Element 632 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(632)); + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 616, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964, 699}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 711, 803, 63, 605, 800, 699, 964, 699}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 803, 63, 605, 800, 699, 964, 699}); + + dieListe.einfuegenBei(12, 210); + Tester.pruefeListenInhalt(dieListe, new int[]{535, 50, 758, 584, 176, 525, 660, 695, 880, 803, 63, 605, 210, 800, 699, 964, 699}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{778}); + + dieListe.einfuegenBei(0, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 778}); + + assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778)); + assertTrue("Fehler: Element 91 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(91)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{91}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(987); + Tester.pruefeListenInhalt(dieListe, new int[]{987}); + + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + assertFalse("Fehler: Element 556 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(556)); + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + dieListe.einfuegenBei(2, 337); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337}); + + assertTrue("Fehler: Element 337 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(337)); + dieListe.einfuegenBei(3, 877); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337, 877}); + + dieListe.einfuegenBei(4, 50); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 955, 337, 877, 50}); + + dieListe.einfuegenBei(1, 987); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 337, 877, 50}); + + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 337, 50}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50}); + + dieListe.anhaengen(666); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 666}); + + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50}); + + assertFalse("Fehler: Element 925 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(925)); + dieListe.einfuegenBei(4, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 788}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 788, 194}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 955, 50, 194}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 50, 194}); + + dieListe.einfuegenBei(4, 451); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 987, 50, 194, 451}); + + assertTrue("Fehler: Element 987 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(987)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 50, 194, 451}); + + dieListe.einfuegenBei(2, 260); + Tester.pruefeListenInhalt(dieListe, new int[]{987, 50, 260, 194, 451}); + + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 260, 194, 451}); + + dieListe.einfuegenBei(1, 248); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 248, 260, 194, 451}); + + dieListe.einfuegenBei(1, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 380, 248, 260, 194, 451}); + + dieListe.anhaengen(13); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 380, 248, 260, 194, 451, 13}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 948); + Tester.pruefeListenInhalt(dieListe, new int[]{948}); + + dieListe.einfuegenBei(1, 800); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 800}); + + dieListe.einfuegenBei(0, 881); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 948, 800}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800}); + + assertTrue("Fehler: Element 881 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(881)); + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 568}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800}); + + dieListe.einfuegenBei(2, 734); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 734}); + + assertTrue("Fehler: Element 800 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(800)); + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 734, 166}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 166}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 800, 166, 974}); + + dieListe.einfuegenBei(1, 814); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 800, 166, 974}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 800, 166}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 814, 166}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{881, 166}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{166}); + + dieListe.einfuegenBei(1, 801); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 801}); + + assertFalse("Fehler: Element 564 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(564)); + dieListe.einfuegenBei(1, 727); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801}); + + assertFalse("Fehler: Element 503 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(503)); + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801, 623}); + + dieListe.anhaengen(58); + Tester.pruefeListenInhalt(dieListe, new int[]{166, 727, 801, 623, 58}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{453}); + + dieListe.einfuegenBei(0, 517); + Tester.pruefeListenInhalt(dieListe, new int[]{517, 453}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{132}); + + dieListe.einfuegenBei(0, 623); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 132}); + + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.einfuegenBei(1, 387); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 132}); + + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 132, 518}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 359}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 359, 845}); + + dieListe.einfuegenBei(3, 177); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 177, 359, 845}); + + assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477)); + dieListe.einfuegenBei(4, 191); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 387, 518, 177, 191, 359, 845}); + + assertTrue("Fehler: Element 177 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(177)); + assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725)); + dieListe.einfuegenBei(0, 837); + Tester.pruefeListenInhalt(dieListe, new int[]{837, 623, 387, 518, 177, 191, 359, 845}); + + assertTrue("Fehler: Element 359 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(359)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{837, 623, 387, 518, 177, 359, 845}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{936}); + + dieListe.anhaengen(0); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0}); + + dieListe.einfuegenBei(2, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 588}); + + assertFalse("Fehler: Element 470 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(470)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0}); + + dieListe.anhaengen(87); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87}); + + assertFalse("Fehler: Element 784 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(784)); + dieListe.anhaengen(872); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87, 872}); + + assertFalse("Fehler: Element 955 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(955)); + dieListe.einfuegenBei(3, 964); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 0, 87, 964, 872}); + + assertTrue("Fehler: Element 0 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(0)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872}); + + dieListe.einfuegenBei(4, 516); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872, 516}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 872, 516, 22}); + + dieListe.einfuegenBei(3, 649); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 649, 872, 516, 22}); + + dieListe.anhaengen(93); + Tester.pruefeListenInhalt(dieListe, new int[]{936, 87, 964, 649, 872, 516, 22, 93}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{828}); + + dieListe.einfuegenBei(1, 113); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 113}); + + assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485)); + assertFalse("Fehler: Element 227 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(227)); + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 113, 306}); + + dieListe.einfuegenBei(2, 27); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 113, 27, 306}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 306}); + + dieListe.anhaengen(28); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 306, 28}); + + assertTrue("Fehler: Element 828 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(828)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28}); + + dieListe.einfuegenBei(3, 511); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28, 511}); + + assertTrue("Fehler: Element 28 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(28)); + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 27, 28, 511, 749}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749}); + + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749, 603}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 511, 749}); + + dieListe.einfuegenBei(2, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749}); + + dieListe.anhaengen(331); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837}); + + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837, 353}); + + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + dieListe.anhaengen(456); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 28, 539, 511, 749, 331, 837, 353, 456}); + + assertTrue("Fehler: Element 456 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(456)); + dieListe.einfuegenBei(0, 524); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 511, 749, 331, 837, 353, 456}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 837, 353, 456}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456}); + + assertTrue("Fehler: Element 28 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(28)); + assertTrue("Fehler: Element 353 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(353)); + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456, 707}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 749, 331, 353, 456}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 331, 353, 456}); + + assertTrue("Fehler: Element 524 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(524)); + assertTrue("Fehler: Element 353 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(353)); + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 828, 28, 539, 331, 353, 456, 264}); + + dieListe.einfuegenBei(1, 119); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264}); + + assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482)); + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264, 127}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{524, 119, 828, 28, 539, 331, 353, 456, 264}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{154}); + + dieListe.einfuegenBei(0, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{572, 154}); + + dieListe.einfuegenBei(0, 253); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154}); + + assertTrue("Fehler: Element 253 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(253)); + dieListe.anhaengen(282); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 282}); + + assertFalse("Fehler: Element 704 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(704)); + dieListe.einfuegenBei(3, 692); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692, 282}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692}); + + assertFalse("Fehler: Element 862 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(862)); + assertTrue("Fehler: Element 253 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(253)); + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.anhaengen(587); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 692, 587}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 154, 587}); + + assertFalse("Fehler: Element 818 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(818)); + assertFalse("Fehler: Element 878 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(878)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 572, 587}); + + assertFalse("Fehler: Element 293 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(293)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{253, 587}); + + assertFalse("Fehler: Element 527 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(527)); + assertTrue("Fehler: Element 587 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(587)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{587}); + + dieListe.einfuegenBei(0, 528); + Tester.pruefeListenInhalt(dieListe, new int[]{528, 587}); + + assertFalse("Fehler: Element 634 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(634)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{175}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 268); + Tester.pruefeListenInhalt(dieListe, new int[]{268}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(239); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(1, 705); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 705}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 77}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 461}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(0, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 239}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{396}); + + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 749}); + + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{396}); + + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + dieListe.einfuegenBei(1, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220}); + + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969}); + + dieListe.anhaengen(739); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969, 739}); + + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 969, 739, 846}); + + dieListe.einfuegenBei(2, 784); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846}); + + dieListe.anhaengen(696); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846, 696}); + + dieListe.anhaengen(509); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 969, 739, 846, 696, 509}); + + assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 509}); + + dieListe.anhaengen(44); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 509, 44}); + + assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 44}); + + assertFalse("Fehler: Element 881 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(881)); + dieListe.anhaengen(947); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 220, 784, 739, 846, 696, 44, 947}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{396, 784, 739, 846, 696, 44, 947}); + + dieListe.einfuegenBei(0, 287); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 396, 784, 739, 846, 696, 44, 947}); + + dieListe.einfuegenBei(6, 982); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 396, 784, 739, 846, 696, 982, 44, 947}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 846, 696, 982, 44, 947}); + + dieListe.einfuegenBei(3, 226); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 226, 846, 696, 982, 44, 947}); + + dieListe.einfuegenBei(2, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 696, 982, 44, 947}); + + dieListe.anhaengen(390); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 696, 982, 44, 947, 390}); + + dieListe.einfuegenBei(6, 850); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 696, 982, 44, 947, 390}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 696, 982, 44, 947}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 980, 739, 226, 846, 850, 982, 44, 947}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 784, 739, 226, 846, 850, 982, 44, 947}); + + assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 846, 850, 982, 44, 947}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947}); + + dieListe.einfuegenBei(2, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 467, 226, 850, 982, 44, 947}); + + assertFalse("Fehler: Element 512 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(512)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 226, 850, 982, 44, 947, 351}); + + dieListe.einfuegenBei(2, 644); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 739, 644, 226, 850, 982, 44, 947, 351}); + + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + assertTrue("Fehler: Element 287 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(287)); + dieListe.einfuegenBei(1, 594); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 739, 644, 226, 850, 982, 44, 947, 351}); + + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 739, 644, 226, 850, 982, 44, 947, 351, 940}); + + dieListe.einfuegenBei(2, 531); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940}); + + dieListe.anhaengen(544); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544}); + + assertFalse("Fehler: Element 35 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(35)); + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544, 409}); + + assertFalse("Fehler: Element 523 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(523)); + assertTrue("Fehler: Element 940 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(940)); + dieListe.einfuegenBei(13, 257); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 44, 947, 351, 940, 544, 257, 409}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 850, 982, 947, 351, 940, 544, 257, 409}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 982, 947, 351, 940, 544, 257, 409}); + + assertTrue("Fehler: Element 226 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(226)); + assertFalse("Fehler: Element 717 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(717)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 982, 947, 351, 940, 257, 409}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 947, 351, 940, 257, 409}); + + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 739, 644, 226, 947, 351, 940, 257, 409, 37}); + + dieListe.einfuegenBei(3, 28); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 28, 739, 644, 226, 947, 351, 940, 257, 409, 37}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{287, 594, 531, 28, 739, 644, 947, 351, 940, 257, 409, 37}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{547}); + + dieListe.einfuegenBei(1, 385); + Tester.pruefeListenInhalt(dieListe, new int[]{547, 385}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{547}); + + assertFalse("Fehler: Element 189 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(189)); + assertTrue("Fehler: Element 547 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(547)); + dieListe.einfuegenBei(1, 346); + Tester.pruefeListenInhalt(dieListe, new int[]{547, 346}); + + dieListe.anhaengen(142); + Tester.pruefeListenInhalt(dieListe, new int[]{547, 346, 142}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 142}); + + assertTrue("Fehler: Element 346 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(346)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{142}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920}); + + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 857}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920}); + + dieListe.anhaengen(715); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715, 964}); + + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(516); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 920, 715, 964, 516}); + + assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964)); + dieListe.einfuegenBei(1, 171); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 920, 715, 964, 516}); + + dieListe.einfuegenBei(2, 48); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 48, 920, 715, 964, 516}); + + dieListe.einfuegenBei(4, 256); + Tester.pruefeListenInhalt(dieListe, new int[]{142, 171, 48, 920, 256, 715, 964, 516}); + + dieListe.einfuegenBei(0, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 964, 516}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 516}); + + assertTrue("Fehler: Element 715 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(715)); + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 142, 171, 48, 920, 256, 715, 516, 725}); + + dieListe.einfuegenBei(1, 295); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516, 725}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516}); + + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 715, 516, 355}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 516, 355}); + + assertFalse("Fehler: Element 930 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(930)); + assertFalse("Fehler: Element 934 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(934)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355}); + + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + dieListe.anhaengen(412); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355, 412}); + + dieListe.anhaengen(823); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 256, 355, 412, 823}); + + dieListe.einfuegenBei(6, 150); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823}); + + dieListe.anhaengen(13); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484}); + + dieListe.anhaengen(493); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493}); + + dieListe.anhaengen(74); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493, 74}); + + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertTrue("Fehler: Element 150 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(150)); + dieListe.anhaengen(489); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489}); + + dieListe.einfuegenBei(6, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489, 417}); + + assertFalse("Fehler: Element 456 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(456)); + dieListe.anhaengen(702); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 489, 417, 702}); + + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + dieListe.einfuegenBei(16, 947); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 417, 702}); + + dieListe.entferneBei(18); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 702}); + + dieListe.einfuegenBei(5, 573); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 74, 947, 489, 702}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 355, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 920, 238, 150, 256, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.einfuegenBei(6, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 794, 920, 238, 150, 256, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 142, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702}); + + dieListe.anhaengen(420); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420}); + + assertFalse("Fehler: Element 723 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(723)); + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420, 207}); + + assertTrue("Fehler: Element 207 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(207)); + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + dieListe.anhaengen(70); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 493, 947, 489, 702, 420, 207, 70}); + + assertTrue("Fehler: Element 412 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(412)); + dieListe.einfuegenBei(13, 373); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 238, 150, 412, 823, 13, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.einfuegenBei(11, 825); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.einfuegenBei(1, 170); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 794, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70, 450}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 207, 70, 450}); + + dieListe.entferneBei(19); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196}); + + dieListe.einfuegenBei(9, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196}); + + dieListe.einfuegenBei(5, 335); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196}); + + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 150, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 573, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935}); + + assertTrue("Fehler: Element 420 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(420)); + assertTrue("Fehler: Element 295 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(295)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441}); + + dieListe.einfuegenBei(2, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441}); + + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + dieListe.anhaengen(558); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558}); + + dieListe.einfuegenBei(1, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 48, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + assertFalse("Fehler: Element 111 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(111)); + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558, 369}); + + dieListe.anhaengen(209); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 348, 935, 441, 558, 369, 209}); + + dieListe.einfuegenBei(23, 243); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.einfuegenBei(19, 523); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 13, 825, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 825, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 295, 171, 335, 920, 412, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.einfuegenBei(4, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 144, 295, 171, 335, 920, 412, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 613, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209}); + + assertFalse("Fehler: Element 121 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(121)); + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + dieListe.anhaengen(48); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209, 48}); + + dieListe.einfuegenBei(16, 365); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 170, 688, 144, 295, 171, 335, 920, 574, 823, 484, 373, 493, 947, 489, 702, 365, 523, 420, 70, 450, 196, 243, 348, 935, 441, 558, 369, 209, 48}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{842}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{767}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 846); + Tester.pruefeListenInhalt(dieListe, new int[]{846}); + + dieListe.anhaengen(433); + Tester.pruefeListenInhalt(dieListe, new int[]{846, 433}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{433}); + + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 466}); + + dieListe.anhaengen(701); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 466, 701}); + + dieListe.einfuegenBei(1, 40); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701, 465}); + + dieListe.einfuegenBei(0, 121); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 433, 40, 466, 701, 465}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 40, 466, 701, 465}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{433, 466, 701, 465}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465}); + + dieListe.anhaengen(94); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94}); + + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660}); + + assertFalse("Fehler: Element 31 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(31)); + dieListe.anhaengen(728); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660, 728}); + + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 660, 728, 683}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 728, 683}); + + dieListe.anhaengen(15); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 465, 94, 728, 683, 15}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 94, 728, 683, 15}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 15}); + + dieListe.anhaengen(384); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 15, 384}); + + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + assertTrue("Fehler: Element 683 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(683)); + assertTrue("Fehler: Element 728 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(728)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 384}); + + dieListe.einfuegenBei(1, 182); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 182, 701, 728, 683, 384}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 701, 728, 683, 384}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 683, 384}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 683, 384, 211}); + + dieListe.einfuegenBei(2, 916); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 728, 916, 683, 384, 211}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211, 450}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 916, 683, 384, 211}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{466, 683, 384, 211}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(916); + Tester.pruefeListenInhalt(dieListe, new int[]{916}); + + dieListe.anhaengen(598); + Tester.pruefeListenInhalt(dieListe, new int[]{916, 598}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{598}); + + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + dieListe.einfuegenBei(1, 161); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 161}); + + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + dieListe.einfuegenBei(1, 483); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 483, 161}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 483}); + + assertTrue("Fehler: Element 483 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(483)); + dieListe.anhaengen(370); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 483, 370}); + + assertFalse("Fehler: Element 266 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(266)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370}); + + dieListe.anhaengen(497); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 497}); + + assertTrue("Fehler: Element 497 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(497)); + dieListe.einfuegenBei(2, 273); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 273, 497}); + + dieListe.einfuegenBei(2, 650); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497, 593}); + + dieListe.einfuegenBei(6, 51); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 273, 497, 593, 51}); + + dieListe.einfuegenBei(3, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 497, 593, 51}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 497, 593, 51, 581}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 593, 51, 581}); + + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 51, 581}); + + dieListe.anhaengen(514); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 175, 273, 51, 581, 514}); + + assertFalse("Fehler: Element 80 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(80)); + dieListe.einfuegenBei(3, 930); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 581, 514}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 581, 514, 23}); + + dieListe.einfuegenBei(7, 375); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23}); + + dieListe.anhaengen(478); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23, 478}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 514, 23, 478, 793}); + + assertTrue("Fehler: Element 514 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(514)); + dieListe.einfuegenBei(9, 303); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 303, 514, 23, 478, 793}); + + assertFalse("Fehler: Element 747 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(747)); + dieListe.einfuegenBei(11, 379); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 273, 51, 375, 581, 303, 514, 379, 23, 478, 793}); + + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 581, 303, 514, 379, 23, 478, 793}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793}); + + dieListe.anhaengen(789); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789}); + + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789, 37}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 379, 23, 478, 793, 789, 37, 727}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 478, 793, 789, 37, 727}); + + assertTrue("Fehler: Element 727 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(727)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 793, 789, 37, 727}); + + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 375, 303, 514, 23, 793, 789, 37, 727, 37}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 303, 514, 23, 793, 789, 37, 727, 37}); + + dieListe.anhaengen(741); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 370, 650, 930, 175, 51, 303, 514, 23, 793, 789, 37, 727, 37, 741}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{280}); + + dieListe.einfuegenBei(0, 744); + Tester.pruefeListenInhalt(dieListe, new int[]{744, 280}); + + dieListe.einfuegenBei(1, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{744, 382, 280}); + + assertTrue("Fehler: Element 744 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(744)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{382, 280}); + + assertTrue("Fehler: Element 280 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(280)); + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{382, 280, 194}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 932); + Tester.pruefeListenInhalt(dieListe, new int[]{932}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 441); + Tester.pruefeListenInhalt(dieListe, new int[]{441}); + + dieListe.anhaengen(248); + Tester.pruefeListenInhalt(dieListe, new int[]{441, 248}); + + assertTrue("Fehler: Element 441 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(441)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{248}); + + assertFalse("Fehler: Element 594 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(594)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{676}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(150); + Tester.pruefeListenInhalt(dieListe, new int[]{150}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{932}); + + dieListe.anhaengen(942); + Tester.pruefeListenInhalt(dieListe, new int[]{932, 942}); + + dieListe.einfuegenBei(0, 162); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 932, 942}); + + dieListe.einfuegenBei(3, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 932, 942, 778}); + + assertFalse("Fehler: Element 241 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(241)); + dieListe.einfuegenBei(1, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366}); + + assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76)); + dieListe.einfuegenBei(6, 134); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134}); + + assertTrue("Fehler: Element 134 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(134)); + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + dieListe.einfuegenBei(7, 464); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134, 464}); + + dieListe.anhaengen(910); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 366, 134, 464, 910}); + + assertFalse("Fehler: Element 822 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(822)); + assertFalse("Fehler: Element 638 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(638)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 932, 942, 778, 134, 464, 910}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 464, 910}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + dieListe.anhaengen(755); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 755}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910}); + + dieListe.einfuegenBei(6, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82}); + + assertTrue("Fehler: Element 910 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(910)); + dieListe.anhaengen(164); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82, 164}); + + dieListe.anhaengen(916); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 82, 164, 916}); + + assertFalse("Fehler: Element 149 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(149)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916}); + + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916, 777}); + + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 164, 916, 777, 618}); + + assertFalse("Fehler: Element 928 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(928)); + dieListe.einfuegenBei(6, 356); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 164, 916, 777, 618}); + + dieListe.einfuegenBei(7, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 239, 164, 916, 777, 618}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 239, 164, 916, 777}); + + assertTrue("Fehler: Element 95 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(95)); + assertTrue("Fehler: Element 777 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(777)); + dieListe.einfuegenBei(7, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 311, 239, 164, 916, 777}); + + assertTrue("Fehler: Element 239 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(239)); + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{162, 95, 942, 778, 134, 910, 356, 311, 239, 164, 916, 777, 774}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{787}); + + assertTrue("Fehler: Element 787 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(787)); + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 750}); + + dieListe.einfuegenBei(2, 158); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 158, 750}); + + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{787, 732, 158, 750, 645}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{196}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{117}); + + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{117, 937}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{117}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 485); + Tester.pruefeListenInhalt(dieListe, new int[]{485}); + + assertTrue("Fehler: Element 485 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(485)); + dieListe.einfuegenBei(0, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 485}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{481}); + + assertFalse("Fehler: Element 898 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(898)); + dieListe.einfuegenBei(1, 285); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 285}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{285}); + + dieListe.anhaengen(133); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133}); + + dieListe.anhaengen(444); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444}); + + assertTrue("Fehler: Element 133 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(133)); + assertFalse("Fehler: Element 393 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(393)); + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + dieListe.einfuegenBei(3, 276); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444, 276}); + + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 444, 276, 213}); + + assertFalse("Fehler: Element 891 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(891)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 133, 276, 213}); + + assertFalse("Fehler: Element 764 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(764)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 276, 213}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{276, 213}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{213}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 251); + Tester.pruefeListenInhalt(dieListe, new int[]{251}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 745); + Tester.pruefeListenInhalt(dieListe, new int[]{745}); + + assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745)); + assertFalse("Fehler: Element 233 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(233)); + assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745)); + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562}); + + dieListe.anhaengen(447); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 447}); + + dieListe.einfuegenBei(2, 274); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447, 620}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 274, 447}); + + dieListe.einfuegenBei(2, 779); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 779, 274, 447}); + + assertTrue("Fehler: Element 447 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(447)); + dieListe.einfuegenBei(2, 118); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 562, 118, 779, 274, 447}); + + assertFalse("Fehler: Element 494 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(494)); + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 903); + Tester.pruefeListenInhalt(dieListe, new int[]{903}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{665}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{605}); + + dieListe.einfuegenBei(0, 446); + Tester.pruefeListenInhalt(dieListe, new int[]{446, 605}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{605}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{900}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{59}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.anhaengen(350); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350, 180}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 350, 853}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853}); + + dieListe.anhaengen(311); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 311}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 634}); + + dieListe.einfuegenBei(2, 243); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 243, 634}); + + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 853, 243, 634, 740}); + + assertFalse("Fehler: Element 11 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(11)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 243, 634, 740}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740}); + + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740, 861}); + + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{350, 634, 740, 861, 828}); + + assertFalse("Fehler: Element 837 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(837)); + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + dieListe.einfuegenBei(0, 664); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 350, 634, 740, 861, 828}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 634, 740, 861, 828}); + + assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 861, 828}); + + dieListe.anhaengen(519); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 861, 828, 519}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{664, 740, 828, 519}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{740, 828, 519}); + + dieListe.einfuegenBei(0, 627); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 828, 519}); + + dieListe.einfuegenBei(2, 518); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 518, 828, 519}); + + assertTrue("Fehler: Element 519 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(519)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 740, 518, 828}); + + dieListe.einfuegenBei(0, 443); + Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 740, 518, 828}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 518, 828}); + + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + dieListe.einfuegenBei(2, 280); + Tester.pruefeListenInhalt(dieListe, new int[]{443, 627, 280, 518, 828}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{425}); + + dieListe.einfuegenBei(1, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 436}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 436, 637}); + + dieListe.einfuegenBei(0, 410); + Tester.pruefeListenInhalt(dieListe, new int[]{410, 425, 436, 637}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 436, 637}); + + dieListe.einfuegenBei(1, 656); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 656, 436, 637}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 61); + Tester.pruefeListenInhalt(dieListe, new int[]{61}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{502}); + + dieListe.einfuegenBei(1, 94); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 94}); + + dieListe.einfuegenBei(0, 755); + Tester.pruefeListenInhalt(dieListe, new int[]{755, 502, 94}); + + dieListe.einfuegenBei(2, 542); + Tester.pruefeListenInhalt(dieListe, new int[]{755, 502, 542, 94}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 542, 94}); + + assertFalse("Fehler: Element 675 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(675)); + assertTrue("Fehler: Element 502 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(502)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 94}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 94, 869}); + + dieListe.einfuegenBei(1, 305); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 305, 94, 869}); + + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 305, 94, 869, 970}); + + assertTrue("Fehler: Element 94 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(94)); + assertTrue("Fehler: Element 94 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(94)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{305, 94, 869, 970}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 970}); + + assertTrue("Fehler: Element 970 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(970)); + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 970, 280}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 280}); + + dieListe.anhaengen(498); + Tester.pruefeListenInhalt(dieListe, new int[]{94, 869, 280, 498}); + + dieListe.einfuegenBei(0, 967); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 94, 869, 280, 498}); + + dieListe.einfuegenBei(1, 124); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 94, 869, 280, 498}); + + dieListe.einfuegenBei(2, 761); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 761, 94, 869, 280, 498}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 124, 761, 94, 869, 280, 498, 157}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{105}); + + dieListe.anhaengen(59); + Tester.pruefeListenInhalt(dieListe, new int[]{105, 59}); + + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{59}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{719}); + + dieListe.einfuegenBei(0, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719}); + + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 487}); + + assertTrue("Fehler: Element 427 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(427)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719}); + + dieListe.einfuegenBei(1, 87); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 87, 719}); + + dieListe.anhaengen(249); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 87, 719, 249}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 249}); + + dieListe.anhaengen(215); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 719, 249, 215}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{719, 249, 215}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest2.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest2.java new file mode 100644 index 0000000..071e274 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest2.java @@ -0,0 +1,2033 @@ +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 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 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 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 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 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 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 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 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 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 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)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest3.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest3.java new file mode 100644 index 0000000..96d041b --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest3.java @@ -0,0 +1,2095 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest3. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest3 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{100}); + + dieListe.anhaengen(544); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544}); + + assertFalse("Fehler: Element 588 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(588)); + assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + dieListe.anhaengen(162); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162}); + + dieListe.anhaengen(238); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69}); + + assertTrue("Fehler: Element 162 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(162)); + assertTrue("Fehler: Element 544 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(544)); + assertTrue("Fehler: Element 238 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(238)); + assertTrue("Fehler: Element 69 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(69)); + dieListe.anhaengen(525); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525}); + + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.anhaengen(565); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565}); + + dieListe.anhaengen(638); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638}); + + assertFalse("Fehler: Element 786 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(786)); + dieListe.anhaengen(561); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561}); + + dieListe.anhaengen(773); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773}); + + dieListe.anhaengen(872); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872}); + + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(802); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502}); + + dieListe.anhaengen(81); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81}); + + dieListe.anhaengen(78); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78}); + + assertTrue("Fehler: Element 638 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(638)); + dieListe.anhaengen(934); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934}); + + dieListe.anhaengen(111); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111}); + + dieListe.anhaengen(342); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413}); + + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + assertTrue("Fehler: Element 565 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(565)); + dieListe.anhaengen(517); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517}); + + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178}); + + assertFalse("Fehler: Element 890 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(890)); + assertFalse("Fehler: Element 289 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(289)); + dieListe.anhaengen(506); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506}); + + assertTrue("Fehler: Element 802 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(884); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219}); + + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998}); + + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168}); + + assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76)); + dieListe.anhaengen(564); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564}); + + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertTrue("Fehler: Element 525 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(525)); + assertTrue("Fehler: Element 506 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(506)); + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869}); + + assertFalse("Fehler: Element 74 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(74)); + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + assertTrue("Fehler: Element 111 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(111)); + assertTrue("Fehler: Element 802 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(130); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620}); + + assertFalse("Fehler: Element 769 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(769)); + assertFalse("Fehler: Element 459 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(459)); + assertFalse("Fehler: Element 484 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(484)); + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + assertTrue("Fehler: Element 564 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(564)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45}); + + dieListe.anhaengen(695); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + assertFalse("Fehler: Element 786 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(786)); + assertFalse("Fehler: Element 71 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(71)); + assertTrue("Fehler: Element 342 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(342)); + assertTrue("Fehler: Element 638 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(638)); + assertTrue("Fehler: Element 81 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(81)); + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122}); + + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368}); + + assertFalse("Fehler: Element 586 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(586)); + assertTrue("Fehler: Element 100 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(100)); + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + assertFalse("Fehler: Element 160 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(160)); + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828}); + + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862}); + + dieListe.anhaengen(810); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810}); + + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499}); + + assertTrue("Fehler: Element 561 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(561)); + assertFalse("Fehler: Element 563 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(563)); + assertFalse("Fehler: Element 747 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(747)); + dieListe.anhaengen(668); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668}); + + assertTrue("Fehler: Element 342 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(342)); + dieListe.anhaengen(193); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668, 193}); + + assertFalse("Fehler: Element 722 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(722)); + assertFalse("Fehler: Element 860 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(860)); + dieListe.anhaengen(930); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668, 193, 930}); + + assertFalse("Fehler: Element 266 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(266)); + assertTrue("Fehler: Element 773 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(773)); + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{100, 544, 162, 238, 69, 525, 146, 565, 638, 561, 773, 872, 802, 502, 81, 78, 934, 111, 342, 413, 517, 178, 506, 884, 219, 998, 168, 564, 411, 869, 130, 909, 620, 45, 695, 122, 368, 146, 828, 769, 862, 810, 499, 668, 193, 930, 110}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(428); + Tester.pruefeListenInhalt(dieListe, new int[]{428}); + + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972}); + + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481}); + + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783}); + + assertFalse("Fehler: Element 735 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(735)); + assertTrue("Fehler: Element 972 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(972)); + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + assertFalse("Fehler: Element 99 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(99)); + dieListe.anhaengen(901); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + assertFalse("Fehler: Element 398 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(398)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583}); + + assertTrue("Fehler: Element 783 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(783)); + assertFalse("Fehler: Element 822 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(822)); + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333}); + + assertFalse("Fehler: Element 108 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(108)); + assertFalse("Fehler: Element 989 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937}); + + dieListe.anhaengen(520); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520}); + + assertFalse("Fehler: Element 270 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(270)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertFalse("Fehler: Element 453 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(453)); + dieListe.anhaengen(599); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599}); + + dieListe.anhaengen(147); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 783 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(783)); + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618}); + + dieListe.anhaengen(523); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523}); + + dieListe.anhaengen(98); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98}); + + dieListe.anhaengen(766); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766}); + + dieListe.anhaengen(960); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593}); + + dieListe.anhaengen(985); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985}); + + dieListe.anhaengen(458); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458}); + + assertTrue("Fehler: Element 147 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(147)); + assertTrue("Fehler: Element 402 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(402)); + assertTrue("Fehler: Element 797 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(797)); + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881}); + + dieListe.anhaengen(813); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813}); + + assertTrue("Fehler: Element 458 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(458)); + dieListe.anhaengen(42); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42}); + + assertFalse("Fehler: Element 990 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(990)); + assertTrue("Fehler: Element 937 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(937)); + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527}); + + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581}); + + dieListe.anhaengen(805); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453}); + + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688}); + + assertTrue("Fehler: Element 382 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(382)); + assertFalse("Fehler: Element 931 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(931)); + assertFalse("Fehler: Element 267 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(267)); + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127}); + + assertFalse("Fehler: Element 930 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(930)); + assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718)); + assertFalse("Fehler: Element 981 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(981)); + dieListe.anhaengen(809); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809}); + + assertTrue("Fehler: Element 813 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(813)); + assertTrue("Fehler: Element 813 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(813)); + dieListe.anhaengen(253); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253}); + + assertTrue("Fehler: Element 458 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(458)); + dieListe.anhaengen(652); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285}); + + dieListe.anhaengen(643); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643}); + + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283}); + + dieListe.anhaengen(643); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643}); + + dieListe.anhaengen(917); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917}); + + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293}); + + assertTrue("Fehler: Element 813 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(813)); + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(14); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14}); + + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 901 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(901)); + dieListe.anhaengen(950); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392}); + + assertFalse("Fehler: Element 169 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(169)); + dieListe.anhaengen(734); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734}); + + assertTrue("Fehler: Element 402 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(402)); + assertTrue("Fehler: Element 127 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(127)); + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213}); + + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992}); + + dieListe.anhaengen(339); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339}); + + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339, 777}); + + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339, 777, 314}); + + assertTrue("Fehler: Element 643 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(643)); + assertTrue("Fehler: Element 285 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(285)); + dieListe.anhaengen(855); + Tester.pruefeListenInhalt(dieListe, new int[]{428, 972, 481, 783, 797, 901, 335, 583, 333, 937, 520, 599, 147, 402, 618, 523, 98, 766, 960, 593, 985, 458, 881, 813, 42, 527, 382, 66, 581, 805, 453, 688, 127, 809, 253, 652, 689, 285, 643, 283, 643, 917, 293, 14, 318, 950, 392, 734, 213, 992, 339, 777, 314, 855}); + + assertFalse("Fehler: Element 775 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(775)); + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{589}); + + assertFalse("Fehler: Element 27 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(27)); + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + assertTrue("Fehler: Element 757 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(757)); + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576}); + + assertFalse("Fehler: Element 464 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(464)); + dieListe.anhaengen(42); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526}); + + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302}); + + assertFalse("Fehler: Element 232 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(232)); + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581}); + + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + assertFalse("Fehler: Element 515 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(515)); + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618}); + + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(945); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945}); + + dieListe.anhaengen(714); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305}); + + assertFalse("Fehler: Element 55 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(55)); + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + assertFalse("Fehler: Element 976 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(5); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5}); + + assertTrue("Fehler: Element 731 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(731)); + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452}); + + assertTrue("Fehler: Element 581 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(462); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462}); + + assertFalse("Fehler: Element 900 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(900)); + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518}); + + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83}); + + dieListe.anhaengen(460); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460}); + + assertFalse("Fehler: Element 737 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(737)); + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547}); + + dieListe.anhaengen(843); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843}); + + dieListe.anhaengen(164); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164}); + + assertTrue("Fehler: Element 419 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(419)); + dieListe.anhaengen(479); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479}); + + dieListe.anhaengen(590); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590}); + + assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358)); + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954}); + + dieListe.anhaengen(325); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325}); + + dieListe.anhaengen(839); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839}); + + assertTrue("Fehler: Element 479 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(479)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(794); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + dieListe.anhaengen(363); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363}); + + assertTrue("Fehler: Element 325 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(325)); + assertFalse("Fehler: Element 62 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(62)); + assertTrue("Fehler: Element 518 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(518)); + assertFalse("Fehler: Element 444 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(444)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688}); + + assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302)); + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329}); + + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + assertFalse("Fehler: Element 698 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(698)); + dieListe.anhaengen(338); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338}); + + dieListe.anhaengen(947); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947}); + + assertTrue("Fehler: Element 714 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(714)); + dieListe.anhaengen(751); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247}); + + assertTrue("Fehler: Element 460 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(460)); + assertFalse("Fehler: Element 31 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(31)); + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637}); + + dieListe.anhaengen(360); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360}); + + assertTrue("Fehler: Element 325 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(325)); + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + dieListe.anhaengen(403); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727}); + + assertTrue("Fehler: Element 462 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(462)); + assertTrue("Fehler: Element 5 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(5)); + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108}); + + dieListe.anhaengen(981); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981}); + + assertTrue("Fehler: Element 305 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(305)); + assertTrue("Fehler: Element 714 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(714)); + assertFalse("Fehler: Element 106 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(106)); + dieListe.anhaengen(176); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176}); + + dieListe.anhaengen(747); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747}); + + dieListe.anhaengen(63); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63}); + + assertFalse("Fehler: Element 635 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(635)); + assertTrue("Fehler: Element 479 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(479)); + assertTrue("Fehler: Element 981 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(981)); + dieListe.anhaengen(174); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63, 174}); + + assertFalse("Fehler: Element 38 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(38)); + assertTrue("Fehler: Element 42 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(42)); + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.anhaengen(435); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63, 174, 435}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 757, 576, 42, 526, 419, 302, 581, 736, 731, 618, 945, 714, 897, 305, 5, 452, 462, 518, 83, 460, 547, 843, 164, 479, 590, 954, 325, 839, 794, 363, 688, 329, 124, 338, 947, 751, 247, 637, 360, 403, 302, 727, 108, 981, 176, 747, 63, 174, 435, 704}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{440}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392}); + + assertTrue("Fehler: Element 440 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(440)); + dieListe.anhaengen(394); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394}); + + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + assertTrue("Fehler: Element 440 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(440)); + assertFalse("Fehler: Element 859 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(859)); + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583}); + + assertFalse("Fehler: Element 7 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(7)); + assertFalse("Fehler: Element 31 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(31)); + dieListe.anhaengen(64); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64}); + + dieListe.anhaengen(17); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180}); + + assertFalse("Fehler: Element 907 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(907)); + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765)); + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + dieListe.anhaengen(537); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537}); + + assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(705); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705}); + + assertFalse("Fehler: Element 356 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(356)); + assertTrue("Fehler: Element 705 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(705)); + assertFalse("Fehler: Element 679 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(679)); + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40}); + + dieListe.anhaengen(887); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887}); + + dieListe.anhaengen(887); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846}); + + assertTrue("Fehler: Element 17 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(17)); + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675}); + + dieListe.anhaengen(173); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528}); + + dieListe.anhaengen(431); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431}); + + assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(600); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600}); + + assertTrue("Fehler: Element 180 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(180)); + assertTrue("Fehler: Element 600 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(600)); + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207}); + + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712}); + + assertTrue("Fehler: Element 64 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(64)); + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + assertTrue("Fehler: Element 600 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(600)); + dieListe.anhaengen(24); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24}); + + assertFalse("Fehler: Element 397 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(397)); + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704}); + + assertFalse("Fehler: Element 324 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(324)); + assertFalse("Fehler: Element 354 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(354)); + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357}); + + assertFalse("Fehler: Element 532 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(532)); + assertFalse("Fehler: Element 598 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(598)); + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + assertTrue("Fehler: Element 537 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(537)); + assertFalse("Fehler: Element 145 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(145)); + dieListe.anhaengen(316); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316}); + + dieListe.anhaengen(112); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112}); + + assertFalse("Fehler: Element 981 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(981)); + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + dieListe.anhaengen(617); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617}); + + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + assertFalse("Fehler: Element 340 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(340)); + assertTrue("Fehler: Element 357 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(357)); + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955}); + + assertFalse("Fehler: Element 877 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(877)); + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535}); + + dieListe.anhaengen(864); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864}); + + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627}); + + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670}); + + assertFalse("Fehler: Element 753 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(753)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertFalse("Fehler: Element 746 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(746)); + assertFalse("Fehler: Element 684 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(684)); + dieListe.anhaengen(834); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834}); + + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123}); + + dieListe.anhaengen(573); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573}); + + assertTrue("Fehler: Element 207 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(207)); + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852}); + + assertTrue("Fehler: Element 394 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(394)); + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23}); + + dieListe.anhaengen(16); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16}); + + assertTrue("Fehler: Element 173 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(173)); + assertFalse("Fehler: Element 721 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(721)); + dieListe.anhaengen(61); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16, 61}); + + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16, 61, 965}); + + assertFalse("Fehler: Element 115 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(115)); + assertFalse("Fehler: Element 666 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(666)); + assertTrue("Fehler: Element 834 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(834)); + assertFalse("Fehler: Element 636 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(636)); + dieListe.anhaengen(661); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 392, 394, 583, 64, 17, 180, 921, 537, 705, 40, 887, 887, 846, 675, 173, 528, 431, 600, 207, 712, 732, 24, 704, 357, 316, 112, 617, 955, 535, 864, 627, 670, 834, 123, 573, 852, 23, 16, 61, 965, 661}); + + assertFalse("Fehler: Element 839 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(839)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{340}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.anhaengen(210); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793}); + + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989}); + + assertFalse("Fehler: Element 654 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(654)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(930); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930}); + + dieListe.anhaengen(591); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + assertTrue("Fehler: Element 521 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(521)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45}); + + assertFalse("Fehler: Element 90 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(90)); + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877}); + + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + assertFalse("Fehler: Element 855 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(855)); + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + dieListe.anhaengen(981); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981}); + + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395}); + + assertTrue("Fehler: Element 45 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(45)); + assertFalse("Fehler: Element 312 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(312)); + assertFalse("Fehler: Element 850 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(850)); + assertFalse("Fehler: Element 659 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(659)); + assertFalse("Fehler: Element 664 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(664)); + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.anhaengen(730); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990}); + + assertTrue("Fehler: Element 591 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(591)); + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499}); + + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(300); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758}); + + assertFalse("Fehler: Element 487 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(487)); + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417}); + + dieListe.anhaengen(136); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136}); + + assertTrue("Fehler: Element 930 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(930)); + assertFalse("Fehler: Element 888 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(888)); + dieListe.anhaengen(159); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159}); + + dieListe.anhaengen(594); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626}); + + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867}); + + dieListe.anhaengen(135); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135}); + + dieListe.anhaengen(768); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768}); + + assertFalse("Fehler: Element 480 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(480)); + dieListe.anhaengen(451); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225}); + + assertFalse("Fehler: Element 185 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(185)); + assertTrue("Fehler: Element 499 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(499)); + assertTrue("Fehler: Element 417 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(417)); + assertFalse("Fehler: Element 609 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(609)); + dieListe.anhaengen(1); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1}); + + assertFalse("Fehler: Element 942 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(942)); + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576}); + + dieListe.anhaengen(54); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + assertTrue("Fehler: Element 417 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(417)); + assertFalse("Fehler: Element 100 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(100)); + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615}); + + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822}); + + dieListe.anhaengen(200); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200}); + + dieListe.anhaengen(696); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696}); + + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.anhaengen(781); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413}); + + assertFalse("Fehler: Element 175 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(175)); + assertTrue("Fehler: Element 874 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(874)); + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439}); + + assertFalse("Fehler: Element 509 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(509)); + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + assertTrue("Fehler: Element 417 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(417)); + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832}); + + assertFalse("Fehler: Element 5 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(5)); + dieListe.anhaengen(698); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698}); + + assertTrue("Fehler: Element 905 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(905)); + assertTrue("Fehler: Element 990 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(990)); + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877}); + + dieListe.anhaengen(830); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830}); + + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562, 217}); + + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); + dieListe.anhaengen(79); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562, 217, 79}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.anhaengen(678); + Tester.pruefeListenInhalt(dieListe, new int[]{340, 210, 118, 521, 905, 793, 989, 930, 591, 874, 45, 3, 877, 645, 981, 395, 348, 730, 990, 499, 300, 758, 126, 417, 136, 159, 594, 626, 867, 135, 768, 451, 225, 1, 576, 54, 463, 526, 615, 822, 200, 696, 781, 57, 413, 439, 837, 832, 698, 970, 877, 830, 562, 217, 79, 678}); + + assertFalse("Fehler: Element 779 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(779)); + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{983}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675}); + + dieListe.anhaengen(165); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165}); + + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820}); + + assertFalse("Fehler: Element 314 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(314)); + assertFalse("Fehler: Element 624 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(624)); + dieListe.anhaengen(792); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312}); + + assertFalse("Fehler: Element 4 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(4)); + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783}); + + assertTrue("Fehler: Element 820 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(820)); + assertFalse("Fehler: Element 406 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(406)); + dieListe.anhaengen(916); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916}); + + assertTrue("Fehler: Element 916 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(916)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170}); + + dieListe.anhaengen(420); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484}); + + assertTrue("Fehler: Element 792 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(792)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736}); + + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 13 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(13)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881}); + + dieListe.anhaengen(728); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750}); + + assertTrue("Fehler: Element 675 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(675)); + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122}); + + assertTrue("Fehler: Element 728 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(728)); + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296}); + + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21}); + + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626}); + + dieListe.anhaengen(903); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903}); + + dieListe.anhaengen(641); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57}); + + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); + dieListe.anhaengen(410); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410}); + + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51}); + + dieListe.anhaengen(238); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238}); + + dieListe.anhaengen(564); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467}); + + dieListe.anhaengen(856); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856}); + + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 201 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(201)); + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723}); + + dieListe.anhaengen(978); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978}); + + assertTrue("Fehler: Element 165 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(165)); + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923}); + + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949}); + + assertTrue("Fehler: Element 296 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(296)); + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362}); + + assertFalse("Fehler: Element 58 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(58)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286}); + + assertTrue("Fehler: Element 750 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(750)); + assertTrue("Fehler: Element 978 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(978)); + assertFalse("Fehler: Element 207 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(207)); + dieListe.anhaengen(35); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35}); + + assertTrue("Fehler: Element 238 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(238)); + dieListe.anhaengen(941); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941}); + + dieListe.anhaengen(366); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366}); + + assertTrue("Fehler: Element 57 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(57)); + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481}); + + assertTrue("Fehler: Element 35 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(35)); + dieListe.anhaengen(183); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183}); + + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664}); + + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575}); + + assertFalse("Fehler: Element 85 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(85)); + assertFalse("Fehler: Element 739 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(739)); + assertTrue("Fehler: Element 51 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(237); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237}); + + dieListe.anhaengen(831); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831}); + + dieListe.anhaengen(371); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371}); + + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + assertFalse("Fehler: Element 613 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(613)); + dieListe.anhaengen(143); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143}); + + assertTrue("Fehler: Element 51 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(51)); + assertTrue("Fehler: Element 983 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(983)); + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937}); + + assertFalse("Fehler: Element 929 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(929)); + assertTrue("Fehler: Element 420 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(420)); + dieListe.anhaengen(655); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655}); + + dieListe.anhaengen(492); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492}); + + dieListe.anhaengen(134); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134}); + + assertTrue("Fehler: Element 923 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(923)); + dieListe.anhaengen(309); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309, 292}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309, 292, 442}); + + assertFalse("Fehler: Element 992 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(992)); + dieListe.anhaengen(53); + Tester.pruefeListenInhalt(dieListe, new int[]{983, 675, 165, 820, 792, 312, 783, 916, 170, 420, 157, 484, 736, 328, 881, 728, 750, 122, 296, 21, 369, 626, 903, 641, 57, 410, 908, 51, 238, 564, 467, 856, 723, 978, 923, 949, 362, 286, 35, 941, 366, 481, 183, 712, 664, 575, 237, 831, 371, 143, 937, 655, 492, 134, 309, 292, 442, 53}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(320); + Tester.pruefeListenInhalt(dieListe, new int[]{320}); + + dieListe.anhaengen(971); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971}); + + assertFalse("Fehler: Element 566 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(566)); + dieListe.anhaengen(281); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281}); + + dieListe.anhaengen(714); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714}); + + assertFalse("Fehler: Element 960 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(960)); + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334}); + + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + dieListe.anhaengen(588); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + dieListe.anhaengen(982); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982}); + + assertFalse("Fehler: Element 868 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(868)); + assertFalse("Fehler: Element 482 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(482)); + dieListe.anhaengen(200); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211}); + + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + assertTrue("Fehler: Element 971 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(971)); + dieListe.anhaengen(537); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537}); + + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157}); + + dieListe.anhaengen(215); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215}); + + assertTrue("Fehler: Element 211 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(211)); + assertTrue("Fehler: Element 896 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(896)); + dieListe.anhaengen(540); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540}); + + dieListe.anhaengen(50); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50}); + + assertTrue("Fehler: Element 982 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(982)); + assertFalse("Fehler: Element 159 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(159)); + assertFalse("Fehler: Element 848 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(848)); + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631}); + + assertFalse("Fehler: Element 777 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(777)); + dieListe.anhaengen(823); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823}); + + dieListe.anhaengen(30); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30}); + + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414}); + + assertFalse("Fehler: Element 548 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(548)); + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633}); + + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596}); + + dieListe.anhaengen(281); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281}); + + dieListe.anhaengen(784); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964}); + + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191}); + + assertTrue("Fehler: Element 537 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(537)); + dieListe.anhaengen(530); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530}); + + assertTrue("Fehler: Element 281 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(281)); + dieListe.anhaengen(301); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301}); + + dieListe.anhaengen(384); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384}); + + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + assertFalse("Fehler: Element 574 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(574)); + assertFalse("Fehler: Element 119 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(119)); + dieListe.anhaengen(948); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948}); + + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466}); + + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774}); + + assertTrue("Fehler: Element 823 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(823)); + assertTrue("Fehler: Element 50 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(50)); + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436}); + + dieListe.anhaengen(120); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120}); + + dieListe.anhaengen(493); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493}); + + dieListe.anhaengen(377); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507}); + + assertTrue("Fehler: Element 120 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(120)); + dieListe.anhaengen(744); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744}); + + assertTrue("Fehler: Element 215 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(215)); + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.anhaengen(702); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329}); + + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473}); + + assertTrue("Fehler: Element 484 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(484)); + assertTrue("Fehler: Element 120 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(120)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328}); + + dieListe.anhaengen(175); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175}); + + dieListe.anhaengen(690); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690}); + + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596}); + + assertFalse("Fehler: Element 799 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(799)); + assertTrue("Fehler: Element 537 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(537)); + dieListe.anhaengen(682); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682}); + + assertFalse("Fehler: Element 683 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(683)); + dieListe.anhaengen(238); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238}); + + dieListe.anhaengen(851); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851}); + + assertFalse("Fehler: Element 831 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(831)); + assertFalse("Fehler: Element 307 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(307)); + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + assertFalse("Fehler: Element 127 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(127)); + assertTrue("Fehler: Element 414 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(414)); + dieListe.anhaengen(109); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109}); + + assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964)); + dieListe.anhaengen(491); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109, 491}); + + assertFalse("Fehler: Element 809 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(809)); + assertTrue("Fehler: Element 823 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(823)); + assertFalse("Fehler: Element 383 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(383)); + dieListe.anhaengen(134); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109, 491, 134}); + + dieListe.anhaengen(558); + Tester.pruefeListenInhalt(dieListe, new int[]{320, 971, 281, 714, 334, 122, 108, 484, 588, 453, 982, 200, 211, 537, 409, 896, 157, 215, 540, 50, 631, 823, 30, 414, 633, 596, 281, 784, 964, 191, 530, 301, 384, 937, 845, 948, 466, 774, 436, 120, 493, 377, 507, 744, 702, 329, 473, 328, 175, 690, 596, 682, 238, 851, 109, 491, 134, 558}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(804); + Tester.pruefeListenInhalt(dieListe, new int[]{804}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + dieListe.anhaengen(93); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93}); + + dieListe.anhaengen(451); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451}); + + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529}); + + assertFalse("Fehler: Element 298 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(298)); + assertTrue("Fehler: Element 93 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124}); + + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257}); + + assertTrue("Fehler: Element 123 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(123)); + dieListe.anhaengen(928); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928}); + + dieListe.anhaengen(629); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629}); + + assertTrue("Fehler: Element 124 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(124)); + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + assertFalse("Fehler: Element 512 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(512)); + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + assertTrue("Fehler: Element 123 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(123)); + dieListe.anhaengen(504); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504}); + + dieListe.anhaengen(841); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + assertTrue("Fehler: Element 504 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(504)); + assertTrue("Fehler: Element 841 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(841)); + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788}); + + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + assertTrue("Fehler: Element 257 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(257)); + assertTrue("Fehler: Element 841 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(841)); + assertTrue("Fehler: Element 123 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(123)); + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589}); + + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + dieListe.anhaengen(836); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836}); + + assertFalse("Fehler: Element 904 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(904)); + dieListe.anhaengen(336); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957}); + + assertFalse("Fehler: Element 732 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(732)); + dieListe.anhaengen(350); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350}); + + assertFalse("Fehler: Element 581 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(581)); + dieListe.anhaengen(789); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789}); + + dieListe.anhaengen(279); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279}); + + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + assertTrue("Fehler: Element 529 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(529)); + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + dieListe.anhaengen(158); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158}); + + assertTrue("Fehler: Element 279 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(279)); + assertTrue("Fehler: Element 928 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(928)); + assertFalse("Fehler: Element 136 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(136)); + assertTrue("Fehler: Element 336 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(336)); + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255}); + + dieListe.anhaengen(669); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359}); + + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392}); + + assertTrue("Fehler: Element 957 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(957)); + assertTrue("Fehler: Element 279 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(279)); + dieListe.anhaengen(569); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569}); + + dieListe.anhaengen(250); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413}); + + assertFalse("Fehler: Element 998 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(998)); + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670}); + + dieListe.anhaengen(925); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925}); + + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650}); + + assertFalse("Fehler: Element 640 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(640)); + assertFalse("Fehler: Element 690 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(690)); + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383}); + + dieListe.anhaengen(789); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789}); + + assertTrue("Fehler: Element 670 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(670)); + assertTrue("Fehler: Element 669 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(669)); + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + dieListe.anhaengen(291); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291}); + + dieListe.anhaengen(927); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927}); + + dieListe.anhaengen(844); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259}); + + assertTrue("Fehler: Element 93 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(93)); + assertTrue("Fehler: Element 877 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(877)); + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + assertFalse("Fehler: Element 508 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(508)); + assertTrue("Fehler: Element 925 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(925)); + dieListe.anhaengen(713); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713}); + + assertTrue("Fehler: Element 257 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(257)); + assertFalse("Fehler: Element 244 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(244)); + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651}); + + dieListe.anhaengen(843); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843}); + + assertTrue("Fehler: Element 145 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(145)); + assertFalse("Fehler: Element 818 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(818)); + assertTrue("Fehler: Element 158 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(158)); + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914}); + + dieListe.anhaengen(643); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914, 643}); + + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914, 643, 732}); + + dieListe.anhaengen(243); + Tester.pruefeListenInhalt(dieListe, new int[]{804, 93, 451, 123, 529, 124, 257, 928, 629, 504, 841, 788, 589, 836, 336, 315, 957, 350, 789, 279, 288, 158, 255, 669, 877, 359, 145, 392, 569, 250, 413, 670, 925, 650, 383, 789, 291, 927, 844, 259, 194, 713, 651, 843, 914, 643, 732, 243}); + + assertTrue("Fehler: Element 650 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(650)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{845}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166}); + + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.anhaengen(961); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.anhaengen(772); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772}); + + dieListe.anhaengen(113); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113}); + + assertFalse("Fehler: Element 321 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(321)); + dieListe.anhaengen(5); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5}); + + dieListe.anhaengen(270); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270}); + + assertFalse("Fehler: Element 651 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(651)); + dieListe.anhaengen(91); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110}); + + assertTrue("Fehler: Element 270 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(270)); + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314}); + + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972}); + + assertTrue("Fehler: Element 972 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(972)); + dieListe.anhaengen(174); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743}); + + assertTrue("Fehler: Element 166 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(166)); + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434}); + + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69}); + + assertFalse("Fehler: Element 124 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(124)); + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419}); + + assertTrue("Fehler: Element 110 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(110)); + dieListe.anhaengen(241); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241}); + + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226}); + + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + assertFalse("Fehler: Element 288 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(288)); + dieListe.anhaengen(847); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847}); + + dieListe.anhaengen(567); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567}); + + assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269)); + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952}); + + assertFalse("Fehler: Element 513 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(513)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395}); + + assertFalse("Fehler: Element 744 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(744)); + dieListe.anhaengen(255); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255}); + + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + assertTrue("Fehler: Element 226 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(226)); + dieListe.anhaengen(773); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 135 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(135)); + assertTrue("Fehler: Element 952 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(952)); + assertFalse("Fehler: Element 903 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(903)); + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + dieListe.anhaengen(139); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139}); + + assertFalse("Fehler: Element 245 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(245)); + assertFalse("Fehler: Element 858 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(858)); + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 222 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(222)); + assertTrue("Fehler: Element 419 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(419)); + assertTrue("Fehler: Element 226 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(226)); + dieListe.anhaengen(480); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675}); + + dieListe.anhaengen(362); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362}); + + assertFalse("Fehler: Element 331 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(331)); + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7}); + + assertTrue("Fehler: Element 91 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(91)); + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975}); + + dieListe.anhaengen(915); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915}); + + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + assertFalse("Fehler: Element 384 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(384)); + dieListe.anhaengen(947); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947}); + + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + assertTrue("Fehler: Element 743 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(743)); + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441}); + + assertFalse("Fehler: Element 65 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(65)); + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958}); + + dieListe.anhaengen(671); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671}); + + assertTrue("Fehler: Element 391 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(391)); + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989}); + + dieListe.anhaengen(849); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849}); + + assertFalse("Fehler: Element 51 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(519); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519, 219}); + + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + assertTrue("Fehler: Element 907 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(907)); + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519, 219, 622}); + + assertTrue("Fehler: Element 983 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(983)); + assertFalse("Fehler: Element 902 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(902)); + assertTrue("Fehler: Element 622 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(622)); + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 166, 961, 772, 113, 5, 270, 91, 326, 110, 314, 972, 174, 743, 434, 255, 69, 419, 241, 226, 847, 567, 952, 395, 255, 773, 139, 907, 453, 480, 557, 675, 362, 7, 975, 915, 947, 983, 99, 26, 877, 391, 441, 958, 671, 989, 849, 519, 219, 622, 822}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{368}); + + dieListe.anhaengen(495); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(317); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317}); + + assertFalse("Fehler: Element 300 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(300)); + dieListe.anhaengen(796); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796}); + + assertFalse("Fehler: Element 126 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(126)); + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401}); + + assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20)); + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870}); + + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(632); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632}); + + dieListe.anhaengen(962); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962}); + + dieListe.anhaengen(374); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + assertFalse("Fehler: Element 550 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(550)); + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736}); + + dieListe.anhaengen(541); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541}); + + dieListe.anhaengen(432); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211}); + + dieListe.anhaengen(386); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + dieListe.anhaengen(12); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12}); + + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168}); + + assertFalse("Fehler: Element 959 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(959)); + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22}); + + assertFalse("Fehler: Element 899 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(899)); + assertFalse("Fehler: Element 940 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(940)); + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254}); + + dieListe.anhaengen(492); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492}); + + dieListe.anhaengen(172); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465}); + + assertFalse("Fehler: Element 611 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(611)); + assertFalse("Fehler: Element 991 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(991)); + dieListe.anhaengen(612); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612}); + + assertTrue("Fehler: Element 12 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(12)); + assertTrue("Fehler: Element 12 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(12)); + assertFalse("Fehler: Element 694 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(694)); + assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485)); + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57}); + + dieListe.anhaengen(520); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520}); + + assertFalse("Fehler: Element 890 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(890)); + assertFalse("Fehler: Element 411 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(411)); + assertTrue("Fehler: Element 92 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(92)); + dieListe.anhaengen(978); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978}); + + dieListe.anhaengen(899); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539}); + + assertFalse("Fehler: Element 260 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(260)); + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359}); + + assertFalse("Fehler: Element 731 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(731)); + dieListe.anhaengen(533); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533}); + + assertFalse("Fehler: Element 76 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(76)); + dieListe.anhaengen(942); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942}); + + assertFalse("Fehler: Element 336 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(336)); + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743}); + + assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140)); + assertFalse("Fehler: Element 346 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(346)); + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292}); + + dieListe.anhaengen(691); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691}); + + dieListe.anhaengen(384); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384}); + + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337}); + + dieListe.anhaengen(363); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363}); + + assertTrue("Fehler: Element 363 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(363)); + assertTrue("Fehler: Element 254 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(254)); + assertTrue("Fehler: Element 22 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(22)); + assertTrue("Fehler: Element 186 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(186)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391}); + + assertTrue("Fehler: Element 386 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(386)); + assertFalse("Fehler: Element 428 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(428)); + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562}); + + assertFalse("Fehler: Element 442 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(442)); + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293}); + + assertFalse("Fehler: Element 128 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(128)); + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + assertFalse("Fehler: Element 505 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(505)); + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940}); + + dieListe.anhaengen(887); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887}); + + assertTrue("Fehler: Element 612 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(612)); + assertFalse("Fehler: Element 112 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(112)); + assertFalse("Fehler: Element 830 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(830)); + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283}); + + dieListe.anhaengen(784); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784}); + + dieListe.anhaengen(706); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706}); + + assertTrue("Fehler: Element 292 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(292)); + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425}); + + dieListe.anhaengen(533); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533}); + + dieListe.anhaengen(378); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533, 378}); + + dieListe.anhaengen(563); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533, 378, 563}); + + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 495, 317, 796, 401, 870, 632, 962, 374, 736, 541, 432, 211, 386, 12, 168, 863, 22, 341, 254, 492, 172, 465, 612, 92, 186, 57, 520, 978, 899, 539, 359, 533, 942, 743, 740, 292, 691, 384, 337, 363, 391, 562, 293, 940, 887, 369, 283, 784, 706, 425, 533, 378, 563, 322}); + + assertFalse("Fehler: Element 851 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(851)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest4.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest4.java new file mode 100644 index 0000000..3267721 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest4.java @@ -0,0 +1,2427 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest4. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest4 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 245); + Tester.pruefeListenInhalt(dieListe, new int[]{245}); + + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 907}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 907, 837}); + + assertFalse("Fehler: Element 897 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(897)); + dieListe.einfuegenBei(3, 307); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 907, 837, 307}); + + dieListe.einfuegenBei(1, 934); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307}); + + dieListe.anhaengen(498); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498}); + + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683}); + + dieListe.einfuegenBei(7, 882); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882}); + + assertFalse("Fehler: Element 435 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(435)); + assertFalse("Fehler: Element 483 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(483)); + dieListe.anhaengen(906); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906}); + + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906, 908}); + + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906, 908, 820}); + + dieListe.anhaengen(730); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 683, 882, 906, 908, 820, 730}); + + dieListe.einfuegenBei(6, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730, 441}); + + dieListe.anhaengen(256); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730, 441, 256}); + + dieListe.anhaengen(848); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848}); + + dieListe.einfuegenBei(6, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43}); + + dieListe.einfuegenBei(0, 676); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166}); + + assertFalse("Fehler: Element 605 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(605)); + assertFalse("Fehler: Element 854 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(854)); + dieListe.einfuegenBei(3, 679); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166}); + + dieListe.einfuegenBei(21, 975); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166, 975}); + + assertFalse("Fehler: Element 914 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(914)); + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 730, 441, 256, 848, 43, 166, 975, 71}); + + dieListe.einfuegenBei(15, 177); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 730, 441, 256, 848, 43, 166, 975, 71}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 730, 441, 256, 848, 43, 166, 975, 71, 860}); + + dieListe.einfuegenBei(16, 545); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860}); + + dieListe.anhaengen(906); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906}); + + assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368)); + assertTrue("Fehler: Element 71 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(71)); + assertTrue("Fehler: Element 975 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(975)); + dieListe.anhaengen(488); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488}); + + dieListe.einfuegenBei(11, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488}); + + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77}); + + dieListe.einfuegenBei(6, 958); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77}); + + dieListe.anhaengen(356); + Tester.pruefeListenInhalt(dieListe, new int[]{676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356}); + + assertFalse("Fehler: Element 49 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(49)); + dieListe.einfuegenBei(0, 14); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356}); + + dieListe.einfuegenBei(33, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 607}); + + dieListe.einfuegenBei(3, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 607}); + + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 607, 97}); + + dieListe.einfuegenBei(34, 795); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 97}); + + assertFalse("Fehler: Element 223 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(223)); + dieListe.einfuegenBei(4, 777); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 97}); + + dieListe.einfuegenBei(37, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + dieListe.einfuegenBei(27, 742); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 742, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertFalse("Fehler: Element 543 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(543)); + dieListe.einfuegenBei(28, 656); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.einfuegenBei(26, 478); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + assertTrue("Fehler: Element 307 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(307)); + dieListe.einfuegenBei(20, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 795, 607, 920, 97, 217}); + + assertTrue("Fehler: Element 256 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(256)); + assertTrue("Fehler: Element 462 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(462)); + dieListe.einfuegenBei(39, 591); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217}); + + dieListe.anhaengen(710); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710}); + + dieListe.einfuegenBei(24, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710}); + + assertFalse("Fehler: Element 146 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710, 861}); + + assertFalse("Fehler: Element 86 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 804 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(804)); + assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394)); + assertTrue("Fehler: Element 97 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(97)); + dieListe.anhaengen(165); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165}); + + assertTrue("Fehler: Element 860 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(860)); + assertFalse("Fehler: Element 470 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(470)); + dieListe.einfuegenBei(39, 501); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165}); + + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383}); + + dieListe.anhaengen(254); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + dieListe.einfuegenBei(4, 504); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 777, 934, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415)); + dieListe.einfuegenBei(7, 748); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + assertFalse("Fehler: Element 222 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(222)); + dieListe.einfuegenBei(5, 442); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166}); + + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertTrue("Fehler: Element 934 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(934)); + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970}); + + assertTrue("Fehler: Element 383 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(383)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589}); + + assertFalse("Fehler: Element 537 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(537)); + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + assertTrue("Fehler: Element 908 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(908)); + dieListe.einfuegenBei(21, 489); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + dieListe.einfuegenBei(38, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + assertFalse("Fehler: Element 875 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(875)); + assertTrue("Fehler: Element 837 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(837)); + dieListe.einfuegenBei(30, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 133, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 970, 589, 124, 853}); + + assertTrue("Fehler: Element 478 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(478)); + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + dieListe.einfuegenBei(59, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 133, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 990, 970, 589, 124, 853}); + + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{14, 676, 245, 553, 504, 442, 777, 934, 748, 679, 907, 837, 958, 307, 498, 743, 688, 683, 126, 882, 906, 489, 908, 820, 462, 177, 545, 730, 360, 441, 133, 256, 848, 478, 43, 742, 656, 166, 975, 234, 71, 860, 906, 488, 77, 501, 356, 591, 795, 607, 920, 97, 217, 710, 861, 165, 383, 254, 166, 990, 970, 589, 124, 853, 625}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(549); + Tester.pruefeListenInhalt(dieListe, new int[]{549}); + + dieListe.einfuegenBei(1, 581); + Tester.pruefeListenInhalt(dieListe, new int[]{549, 581}); + + dieListe.einfuegenBei(1, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{549, 368, 581}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.einfuegenBei(1, 748); + Tester.pruefeListenInhalt(dieListe, new int[]{549, 748, 368, 581}); + + dieListe.einfuegenBei(0, 102); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581}); + + assertFalse("Fehler: Element 821 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(821)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189}); + + assertFalse("Fehler: Element 56 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(56)); + dieListe.anhaengen(657); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657}); + + dieListe.anhaengen(358); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358}); + + dieListe.anhaengen(706); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417}); + + dieListe.anhaengen(824); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824}); + + dieListe.anhaengen(506); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506}); + + dieListe.anhaengen(260); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 260}); + + assertTrue("Fehler: Element 549 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(549)); + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 260, 66}); + + dieListe.einfuegenBei(2, 855); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 260, 66}); + + assertFalse("Fehler: Element 723 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(723)); + dieListe.einfuegenBei(13, 8); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 8, 260, 66}); + + dieListe.einfuegenBei(15, 226); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66}); + + assertFalse("Fehler: Element 44 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(44)); + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66, 689}); + + assertTrue("Fehler: Element 358 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(358)); + dieListe.einfuegenBei(7, 2); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66, 689}); + + dieListe.einfuegenBei(1, 267); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 260, 226, 66, 689}); + + dieListe.einfuegenBei(16, 861); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689}); + + assertTrue("Fehler: Element 824 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(824)); + dieListe.anhaengen(953); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 953}); + + dieListe.einfuegenBei(1, 677); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 953}); + + dieListe.einfuegenBei(22, 950); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 950, 953}); + + dieListe.einfuegenBei(8, 163); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 226, 66, 689, 950, 953}); + + dieListe.einfuegenBei(20, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861)); + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.einfuegenBei(16, 62); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + assertFalse("Fehler: Element 171 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(171)); + dieListe.einfuegenBei(7, 637); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.einfuegenBei(7, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.einfuegenBei(19, 625); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972}); + + dieListe.anhaengen(524); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524}); + + assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102)); + assertFalse("Fehler: Element 16 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(16)); + dieListe.anhaengen(113); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113}); + + dieListe.anhaengen(899); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860}); + + dieListe.einfuegenBei(6, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312}); + + dieListe.einfuegenBei(13, 949); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312}); + + dieListe.anhaengen(445); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 445}); + + dieListe.anhaengen(156); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 445, 156}); + + assertTrue("Fehler: Element 824 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(824)); + assertTrue("Fehler: Element 445 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(445)); + dieListe.einfuegenBei(38, 261); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 156}); + + assertFalse("Fehler: Element 907 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(907)); + dieListe.einfuegenBei(41, 718); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 156, 718}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + assertTrue("Fehler: Element 62 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(62)); + dieListe.einfuegenBei(40, 288); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718}); + + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992}); + + assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415)); + dieListe.anhaengen(30); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + dieListe.einfuegenBei(2, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + dieListe.einfuegenBei(29, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + assertTrue("Fehler: Element 713 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(713)); + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + dieListe.einfuegenBei(39, 850); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329}); + + dieListe.anhaengen(776); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776}); + + dieListe.einfuegenBei(7, 328); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776}); + + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907}); + + assertFalse("Fehler: Element 4 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(4)); + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689}); + + assertFalse("Fehler: Element 866 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(866)); + dieListe.anhaengen(621); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442}); + + assertTrue("Fehler: Element 62 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(62)); + dieListe.anhaengen(800); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800}); + + assertFalse("Fehler: Element 480 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(480)); + dieListe.einfuegenBei(30, 864); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800}); + + dieListe.einfuegenBei(9, 440); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800}); + + assertTrue("Fehler: Element 288 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(288)); + dieListe.anhaengen(422); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422}); + + assertFalse("Fehler: Element 854 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(854)); + dieListe.anhaengen(645); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645}); + + dieListe.anhaengen(582); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582}); + + dieListe.einfuegenBei(10, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582}); + + dieListe.anhaengen(404); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404}); + + assertFalse("Fehler: Element 719 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(719)); + dieListe.einfuegenBei(31, 904); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787}); + + dieListe.anhaengen(244); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787, 244}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787, 244, 570}); + + dieListe.einfuegenBei(7, 835); + Tester.pruefeListenInhalt(dieListe, new int[]{102, 677, 239, 267, 549, 855, 748, 835, 328, 360, 440, 362, 368, 788, 637, 581, 163, 189, 949, 2, 657, 358, 706, 417, 824, 62, 625, 506, 8, 861, 260, 21, 904, 226, 864, 713, 66, 689, 950, 953, 972, 524, 113, 899, 860, 850, 312, 261, 445, 288, 156, 718, 992, 30, 157, 469, 329, 776, 907, 689, 621, 442, 800, 422, 645, 582, 404, 787, 244, 570}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{588}); + + dieListe.anhaengen(889); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889}); + + assertTrue("Fehler: Element 889 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(889)); + dieListe.anhaengen(884); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 884}); + + assertFalse("Fehler: Element 467 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(467)); + dieListe.anhaengen(151); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 884, 151}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 884, 151, 57}); + + dieListe.einfuegenBei(2, 960); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 884, 151, 57}); + + assertFalse("Fehler: Element 612 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(612)); + dieListe.anhaengen(385); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 884, 151, 57, 385}); + + dieListe.anhaengen(530); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 884, 151, 57, 385, 530}); + + dieListe.einfuegenBei(3, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 884, 151, 57, 385, 530}); + + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 884, 151, 57, 385, 530, 637}); + + assertTrue("Fehler: Element 960 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(960)); + dieListe.einfuegenBei(8, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 884, 151, 57, 385, 647, 530, 637}); + + dieListe.einfuegenBei(4, 391); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 647, 530, 637}); + + dieListe.einfuegenBei(9, 196); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637}); + + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271}); + + assertFalse("Fehler: Element 435 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(435)); + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650}); + + dieListe.einfuegenBei(0, 854); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650}); + + dieListe.einfuegenBei(4, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650}); + + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + assertFalse("Fehler: Element 9 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(9)); + dieListe.anhaengen(141); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650, 141}); + + dieListe.anhaengen(613); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 151, 57, 385, 196, 647, 530, 637, 271, 650, 141, 613}); + + dieListe.einfuegenBei(8, 720); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 196, 647, 530, 637, 271, 650, 141, 613}); + + dieListe.einfuegenBei(12, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 613}); + + dieListe.einfuegenBei(20, 432); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 432, 613}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 432, 613, 326}); + + assertTrue("Fehler: Element 78 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(78)); + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 271, 650, 141, 432, 613, 326, 92}); + + dieListe.einfuegenBei(17, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92}); + + dieListe.einfuegenBei(1, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92}); + + assertTrue("Fehler: Element 185 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(185)); + dieListe.einfuegenBei(12, 425); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92}); + + assertTrue("Fehler: Element 613 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(613)); + assertTrue("Fehler: Element 196 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(196)); + dieListe.anhaengen(598); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598}); + + dieListe.einfuegenBei(13, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598}); + + dieListe.anhaengen(195); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195}); + + assertFalse("Fehler: Element 551 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(551)); + assertFalse("Fehler: Element 550 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(550)); + dieListe.anhaengen(582); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582}); + + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487}); + + dieListe.einfuegenBei(17, 773); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487}); + + assertFalse("Fehler: Element 769 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(769)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170}); + + dieListe.einfuegenBei(17, 838); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170, 883}); + + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170, 883, 296}); + + dieListe.anhaengen(621); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 195, 582, 487, 170, 883, 296, 621}); + + dieListe.einfuegenBei(31, 46); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621}); + + assertFalse("Fehler: Element 822 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(822)); + dieListe.einfuegenBei(8, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621}); + + assertTrue("Fehler: Element 196 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(196)); + assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20)); + dieListe.anhaengen(179); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179}); + + dieListe.einfuegenBei(8, 744); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179}); + + dieListe.anhaengen(293); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293}); + + dieListe.einfuegenBei(15, 871); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293}); + + dieListe.anhaengen(361); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 361}); + + dieListe.anhaengen(301); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 361, 301}); + + dieListe.einfuegenBei(44, 974); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301}); + + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301, 583}); + + dieListe.anhaengen(324); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301, 583, 324}); + + dieListe.einfuegenBei(13, 446); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 301, 583, 324}); + + assertFalse("Fehler: Element 23 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(23)); + assertTrue("Fehler: Element 324 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(324)); + dieListe.einfuegenBei(47, 505); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 583, 324}); + + dieListe.einfuegenBei(19, 321); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 583, 324}); + + assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195)); + dieListe.einfuegenBei(50, 815); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324}); + + dieListe.anhaengen(649); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649}); + + assertFalse("Fehler: Element 451 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(451)); + dieListe.einfuegenBei(38, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649}); + + dieListe.einfuegenBei(31, 405); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649}); + + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + dieListe.anhaengen(692); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692}); + + dieListe.einfuegenBei(26, 558); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692}); + + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932}); + + assertFalse("Fehler: Element 229 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(229)); + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69}); + + assertTrue("Fehler: Element 613 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(613)); + assertFalse("Fehler: Element 615 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(615)); + dieListe.einfuegenBei(11, 480); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69}); + + assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313)); + dieListe.anhaengen(667); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69, 667}); + + dieListe.anhaengen(393); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393}); + + dieListe.anhaengen(830); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393, 830}); + + dieListe.einfuegenBei(54, 978); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393, 830}); + + dieListe.einfuegenBei(26, 901); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 901, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 667, 393, 830}); + + dieListe.einfuegenBei(64, 207); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 901, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 207, 667, 393, 830}); + + assertFalse("Fehler: Element 851 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(851)); + assertFalse("Fehler: Element 251 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(251)); + assertFalse("Fehler: Element 653 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(653)); + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 743, 588, 889, 960, 185, 689, 391, 744, 874, 884, 480, 720, 151, 446, 57, 425, 871, 481, 385, 321, 78, 196, 838, 773, 647, 901, 530, 558, 637, 91, 271, 650, 141, 405, 432, 613, 326, 92, 598, 46, 195, 36, 582, 487, 170, 883, 296, 621, 179, 293, 974, 361, 505, 301, 978, 815, 583, 324, 649, 692, 932, 583, 69, 207, 667, 393, 830, 51}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{390}); + + dieListe.einfuegenBei(1, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75}); + + dieListe.einfuegenBei(2, 282); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75, 282}); + + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75, 282, 653}); + + assertFalse("Fehler: Element 195 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(195)); + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 75, 282, 653, 596}); + + dieListe.einfuegenBei(1, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{390, 398, 75, 282, 653, 596}); + + assertFalse("Fehler: Element 636 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(636)); + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.einfuegenBei(0, 461); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 282, 653, 596}); + + dieListe.einfuegenBei(4, 586); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.anhaengen(144); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596, 144}); + + dieListe.anhaengen(104); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596, 144, 104}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 586, 282, 653, 596, 144, 104, 619}); + + assertFalse("Fehler: Element 834 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(834)); + dieListe.einfuegenBei(4, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299}); + + assertTrue("Fehler: Element 461 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(461)); + dieListe.anhaengen(617); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617}); + + dieListe.anhaengen(233); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233}); + + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233, 92}); + + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233, 92, 306}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 619, 299, 617, 233, 92, 306, 225}); + + dieListe.einfuegenBei(11, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225}); + + dieListe.anhaengen(678); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678}); + + assertFalse("Fehler: Element 332 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(332)); + dieListe.einfuegenBei(5, 129); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312}); + + dieListe.anhaengen(202); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202}); + + assertFalse("Fehler: Element 500 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(500)); + assertFalse("Fehler: Element 264 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(264)); + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + dieListe.einfuegenBei(7, 312); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 75, 736, 129, 586, 312, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + dieListe.einfuegenBei(3, 299); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + assertTrue("Fehler: Element 596 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(596)); + dieListe.einfuegenBei(11, 335); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965}); + + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353}); + + dieListe.anhaengen(94); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94}); + + assertFalse("Fehler: Element 928 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(928)); + assertFalse("Fehler: Element 799 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(799)); + assertFalse("Fehler: Element 976 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(913); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913}); + + assertFalse("Fehler: Element 473 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(473)); + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264}); + + dieListe.anhaengen(468); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 468}); + + dieListe.einfuegenBei(17, 868); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 468}); + + dieListe.einfuegenBei(20, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 468}); + + dieListe.einfuegenBei(33, 781); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 781, 468}); + + dieListe.einfuegenBei(35, 786); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 781, 468, 786}); + + dieListe.einfuegenBei(33, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786}); + + dieListe.einfuegenBei(6, 25); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786}); + + dieListe.anhaengen(451); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + assertTrue("Fehler: Element 736 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(736)); + dieListe.einfuegenBei(20, 337); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + assertFalse("Fehler: Element 381 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(381)); + dieListe.einfuegenBei(12, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + assertTrue("Fehler: Element 335 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(335)); + dieListe.einfuegenBei(31, 389); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451}); + + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.anhaengen(287); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110}); + + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989}); + + dieListe.anhaengen(850); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850}); + + dieListe.anhaengen(227); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227}); + + assertFalse("Fehler: Element 539 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(539)); + assertFalse("Fehler: Element 773 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(773)); + assertTrue("Fehler: Element 312 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(312)); + assertFalse("Fehler: Element 500 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(500)); + dieListe.anhaengen(106); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106}); + + dieListe.einfuegenBei(8, 894); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106}); + + assertFalse("Fehler: Element 541 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(541)); + dieListe.einfuegenBei(1, 792); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106}); + + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535}); + + dieListe.anhaengen(987); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987}); + + assertTrue("Fehler: Element 92 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(92)); + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.einfuegenBei(26, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543}); + + dieListe.einfuegenBei(22, 786); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.anhaengen(400); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 989, 850, 227, 106, 535, 987, 543, 400}); + + assertFalse("Fehler: Element 582 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(582)); + dieListe.einfuegenBei(49, 463); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400}); + + assertTrue("Fehler: Element 25 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(25)); + assertFalse("Fehler: Element 964 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(964)); + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89}); + + dieListe.anhaengen(190); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(18, 317); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(29, 519); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(53, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(23, 115); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + dieListe.einfuegenBei(41, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 991, 94, 913, 264, 481, 781, 468, 786, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(49, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 991, 94, 913, 264, 481, 781, 468, 786, 555, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + dieListe.einfuegenBei(7, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{461, 792, 390, 398, 299, 75, 736, 546, 25, 129, 894, 586, 312, 282, 653, 980, 335, 596, 144, 317, 104, 157, 619, 868, 115, 786, 299, 337, 617, 707, 813, 519, 233, 92, 306, 225, 678, 312, 202, 389, 965, 353, 991, 94, 913, 264, 481, 781, 468, 786, 555, 451, 863, 287, 110, 463, 989, 144, 850, 227, 106, 535, 987, 543, 400, 89, 190}); + + assertFalse("Fehler: Element 691 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(691)); + assertFalse("Fehler: Element 791 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(791)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 805); + Tester.pruefeListenInhalt(dieListe, new int[]{805}); + + dieListe.anhaengen(610); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 610}); + + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 610, 467}); + + dieListe.einfuegenBei(1, 890); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467}); + + dieListe.anhaengen(552); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935}); + + dieListe.anhaengen(46); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935, 46}); + + dieListe.einfuegenBei(7, 460); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935, 46, 460}); + + dieListe.anhaengen(994); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 467, 552, 935, 46, 460, 994}); + + assertTrue("Fehler: Element 552 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(552)); + assertTrue("Fehler: Element 552 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(552)); + dieListe.einfuegenBei(3, 787); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 787, 467, 552, 935, 46, 460, 994}); + + assertFalse("Fehler: Element 385 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(385)); + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 787, 467, 552, 935, 46, 460, 994, 646}); + + assertFalse("Fehler: Element 934 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(934)); + dieListe.einfuegenBei(3, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 994, 646}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 994, 646, 297}); + + dieListe.einfuegenBei(11, 99); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 994, 99, 646, 297}); + + assertTrue("Fehler: Element 805 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(805)); + assertFalse("Fehler: Element 565 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(565)); + dieListe.einfuegenBei(10, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 144, 994, 99, 646, 297}); + + assertFalse("Fehler: Element 247 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(247)); + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 144, 994, 99, 646, 297, 417}); + + dieListe.einfuegenBei(14, 433); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 144, 994, 99, 646, 433, 297, 417}); + + assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890)); + dieListe.einfuegenBei(10, 693); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 693, 144, 994, 99, 646, 433, 297, 417}); + + dieListe.einfuegenBei(14, 680); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 693, 144, 994, 99, 680, 646, 433, 297, 417}); + + dieListe.einfuegenBei(10, 114); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 99, 680, 646, 433, 297, 417}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 99, 680, 646, 433, 297, 417, 469}); + + dieListe.einfuegenBei(14, 310); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 680, 646, 433, 297, 417, 469}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 680, 646, 433, 297, 417, 469, 351}); + + dieListe.einfuegenBei(16, 791); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 680, 646, 433, 297, 417, 469, 351}); + + dieListe.anhaengen(982); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 680, 646, 433, 297, 417, 469, 351, 982}); + + dieListe.anhaengen(404); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 680, 646, 433, 297, 417, 469, 351, 982, 404}); + + dieListe.einfuegenBei(17, 184); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404}); + + dieListe.anhaengen(765); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.einfuegenBei(5, 285); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.einfuegenBei(10, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.einfuegenBei(13, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743}); + + assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816}); + + assertFalse("Fehler: Element 269 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(269)); + assertFalse("Fehler: Element 833 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(833)); + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908}); + + assertTrue("Fehler: Element 765 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(765)); + dieListe.einfuegenBei(6, 66); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908}); + + dieListe.einfuegenBei(10, 519); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908}); + + dieListe.anhaengen(513); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513}); + + dieListe.anhaengen(427); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427}); + + assertFalse("Fehler: Element 528 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(528)); + dieListe.anhaengen(961); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315}); + + dieListe.anhaengen(68); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68}); + + assertTrue("Fehler: Element 184 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(184)); + assertTrue("Fehler: Element 310 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(310)); + assertFalse("Fehler: Element 418 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(418)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170}); + + dieListe.einfuegenBei(19, 635); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170}); + + dieListe.einfuegenBei(6, 385); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170}); + + assertTrue("Fehler: Element 310 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(310)); + dieListe.anhaengen(304); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304}); + + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89}); + + dieListe.anhaengen(475); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475}); + + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328}); + + assertTrue("Fehler: Element 89 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(89)); + assertTrue("Fehler: Element 328 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(328)); + dieListe.anhaengen(943); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943}); + + dieListe.einfuegenBei(38, 338); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943}); + + assertFalse("Fehler: Element 534 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(534)); + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763}); + + dieListe.einfuegenBei(11, 506); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763}); + + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463}); + + dieListe.anhaengen(416); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416}); + + dieListe.einfuegenBei(12, 88); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416}); + + dieListe.einfuegenBei(8, 469); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416}); + + assertFalse("Fehler: Element 493 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(493)); + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + dieListe.einfuegenBei(34, 410); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487}); + + assertTrue("Fehler: Element 805 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(805)); + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487, 867}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + dieListe.einfuegenBei(36, 286); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + assertFalse("Fehler: Element 618 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(618)); + assertFalse("Fehler: Element 383 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(383)); + dieListe.einfuegenBei(53, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + dieListe.einfuegenBei(36, 800); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + assertTrue("Fehler: Element 404 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(404)); + dieListe.einfuegenBei(35, 232); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + dieListe.einfuegenBei(10, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + assertTrue("Fehler: Element 610 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(610)); + dieListe.einfuegenBei(10, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 686, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + dieListe.einfuegenBei(58, 867); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 686, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 867, 475, 328, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + assertTrue("Fehler: Element 88 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(88)); + dieListe.einfuegenBei(61, 230); + Tester.pruefeListenInhalt(dieListe, new int[]{805, 890, 610, 234, 787, 285, 385, 66, 469, 467, 686, 976, 552, 935, 506, 88, 519, 46, 95, 460, 114, 922, 693, 144, 994, 635, 310, 99, 791, 184, 680, 646, 433, 297, 417, 469, 410, 232, 351, 800, 286, 982, 404, 765, 620, 743, 816, 338, 908, 513, 427, 961, 315, 68, 170, 304, 89, 741, 867, 475, 328, 230, 943, 763, 318, 463, 416, 487, 867, 861, 860}); + + assertTrue("Fehler: Element 994 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(994)); + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 903); + Tester.pruefeListenInhalt(dieListe, new int[]{903}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723, 593}); + + dieListe.anhaengen(546); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723, 593, 546}); + + dieListe.anhaengen(300); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 723, 593, 546, 300}); + + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + dieListe.einfuegenBei(1, 529); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 593, 546, 300}); + + dieListe.einfuegenBei(3, 914); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 546, 300}); + + assertFalse("Fehler: Element 873 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(873)); + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 546, 300, 334}); + + dieListe.einfuegenBei(5, 696); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 696, 546, 300, 334}); + + dieListe.anhaengen(443); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 696, 546, 300, 334, 443}); + + dieListe.einfuegenBei(6, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 914, 593, 696, 92, 546, 300, 334, 443}); + + dieListe.einfuegenBei(3, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 688, 914, 593, 696, 92, 546, 300, 334, 443}); + + dieListe.anhaengen(514); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 723, 688, 914, 593, 696, 92, 546, 300, 334, 443, 514}); + + assertFalse("Fehler: Element 882 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(882)); + assertTrue("Fehler: Element 514 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(514)); + dieListe.einfuegenBei(2, 17); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 696, 92, 546, 300, 334, 443, 514}); + + dieListe.einfuegenBei(7, 326); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47}); + + dieListe.anhaengen(752); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752}); + + dieListe.anhaengen(836); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752, 836}); + + assertFalse("Fehler: Element 730 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(730)); + assertTrue("Fehler: Element 443 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(443)); + assertTrue("Fehler: Element 514 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(514)); + assertTrue("Fehler: Element 443 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(443)); + assertTrue("Fehler: Element 723 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(723)); + dieListe.einfuegenBei(2, 217); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752, 836}); + + dieListe.anhaengen(624); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 514, 47, 752, 836, 624}); + + dieListe.einfuegenBei(15, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463}); + + dieListe.anhaengen(559); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559}); + + assertTrue("Fehler: Element 463 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(463)); + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322}); + + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322, 890}); + + assertFalse("Fehler: Element 14 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(14)); + assertTrue("Fehler: Element 17 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(17)); + dieListe.einfuegenBei(2, 342); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322, 890}); + + dieListe.anhaengen(228); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228}); + + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.einfuegenBei(17, 433); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228}); + + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731}); + + dieListe.anhaengen(583); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + assertTrue("Fehler: Element 752 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(752)); + dieListe.einfuegenBei(19, 358); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + assertFalse("Fehler: Element 754 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(754)); + dieListe.einfuegenBei(5, 541); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + dieListe.einfuegenBei(18, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583}); + + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583, 382}); + + assertFalse("Fehler: Element 974 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(974)); + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583, 382, 783}); + + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 731, 583, 382, 783, 335}); + + dieListe.einfuegenBei(31, 12); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 12, 731, 583, 382, 783, 335}); + + dieListe.einfuegenBei(18, 752); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 12, 731, 583, 382, 783, 335}); + + assertFalse("Fehler: Element 892 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(892)); + dieListe.anhaengen(572); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 228, 12, 731, 583, 382, 783, 335, 572}); + + assertFalse("Fehler: Element 600 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(600)); + dieListe.einfuegenBei(31, 301); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 731, 583, 382, 783, 335, 572}); + + dieListe.einfuegenBei(18, 343); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 731, 583, 382, 783, 335, 572}); + + dieListe.anhaengen(622); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 731, 583, 382, 783, 335, 572, 622}); + + dieListe.einfuegenBei(35, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622}); + + assertTrue("Fehler: Element 343 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(343)); + dieListe.einfuegenBei(16, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622}); + + assertTrue("Fehler: Element 731 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(731)); + dieListe.anhaengen(17); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17}); + + assertFalse("Fehler: Element 508 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(508)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + assertFalse("Fehler: Element 86 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 175 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(175)); + dieListe.anhaengen(817); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.einfuegenBei(8, 767); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.einfuegenBei(25, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.einfuegenBei(38, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817, 557}); + + assertTrue("Fehler: Element 572 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(572)); + assertTrue("Fehler: Element 767 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(767)); + assertTrue("Fehler: Element 433 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(433)); + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 572, 622, 17, 189, 817, 557, 534}); + + assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501)); + dieListe.einfuegenBei(45, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 534}); + + dieListe.einfuegenBei(52, 868); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534}); + + dieListe.anhaengen(567); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567}); + + dieListe.einfuegenBei(38, 263); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567}); + + dieListe.einfuegenBei(35, 376); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567}); + + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 534, 567, 659}); + + dieListe.einfuegenBei(55, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659}); + + dieListe.einfuegenBei(39, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659}); + + dieListe.einfuegenBei(48, 542); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659}); + + dieListe.anhaengen(125); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125}); + + dieListe.einfuegenBei(17, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125}); + + dieListe.anhaengen(727); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125, 727}); + + dieListe.einfuegenBei(52, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 208, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125, 727}); + + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + assertFalse("Fehler: Element 27 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(27)); + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{903, 529, 342, 217, 17, 541, 723, 688, 767, 914, 593, 326, 696, 92, 546, 300, 334, 105, 689, 443, 109, 343, 752, 749, 433, 514, 126, 358, 47, 752, 836, 624, 463, 559, 322, 890, 376, 301, 228, 12, 218, 263, 990, 75, 731, 583, 382, 783, 335, 542, 665, 572, 208, 622, 17, 189, 817, 557, 868, 445, 534, 567, 659, 125, 727, 605}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{627}); + + dieListe.einfuegenBei(0, 602); + Tester.pruefeListenInhalt(dieListe, new int[]{602, 627}); + + dieListe.einfuegenBei(0, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 602, 627}); + + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 602, 627, 623}); + + dieListe.einfuegenBei(0, 793); + Tester.pruefeListenInhalt(dieListe, new int[]{793, 208, 602, 627, 623}); + + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + dieListe.einfuegenBei(1, 378); + Tester.pruefeListenInhalt(dieListe, new int[]{793, 378, 208, 602, 627, 623}); + + dieListe.einfuegenBei(0, 687); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 602, 627, 623}); + + dieListe.einfuegenBei(4, 993); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623}); + + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 699}); + + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 699, 725}); + + dieListe.einfuegenBei(10, 527); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 699, 725, 527}); + + dieListe.einfuegenBei(8, 429); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 527}); + + assertFalse("Fehler: Element 280 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(280)); + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 527, 861}); + + dieListe.anhaengen(782); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 527, 861, 782}); + + dieListe.einfuegenBei(11, 516); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 527, 861, 782}); + + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 527, 861, 782, 401}); + + assertFalse("Fehler: Element 79 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(79)); + dieListe.einfuegenBei(12, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 42, 527, 861, 782, 401}); + + assertFalse("Fehler: Element 410 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(410)); + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 725, 516, 42, 527, 861, 782, 401, 595}); + + dieListe.einfuegenBei(10, 733); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595}); + + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595, 832}); + + dieListe.einfuegenBei(20, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413}); + + assertTrue("Fehler: Element 782 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(782)); + assertFalse("Fehler: Element 423 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(423)); + assertFalse("Fehler: Element 920 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(356); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356}); + + dieListe.einfuegenBei(11, 938); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356}); + + dieListe.einfuegenBei(10, 744); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 356, 700}); + + dieListe.einfuegenBei(23, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 527, 861, 782, 401, 595, 832, 413, 766, 356, 700}); + + dieListe.einfuegenBei(16, 855); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 699, 744, 733, 938, 725, 516, 42, 855, 527, 861, 782, 401, 595, 832, 413, 766, 356, 700}); + + dieListe.einfuegenBei(9, 978); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 527, 861, 782, 401, 595, 832, 413, 766, 356, 700}); + + assertTrue("Fehler: Element 938 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(938)); + dieListe.einfuegenBei(26, 508); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700}); + + assertFalse("Fehler: Element 775 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(775)); + assertTrue("Fehler: Element 700 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(700)); + dieListe.einfuegenBei(18, 619); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576}); + + dieListe.anhaengen(561); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561}); + + dieListe.anhaengen(132); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132}); + + assertTrue("Fehler: Element 855 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(855)); + assertTrue("Fehler: Element 208 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(208)); + assertTrue("Fehler: Element 855 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(855)); + assertFalse("Fehler: Element 986 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(986)); + assertFalse("Fehler: Element 945 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(945)); + dieListe.einfuegenBei(5, 469); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110}); + + dieListe.einfuegenBei(0, 954); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110}); + + dieListe.anhaengen(546); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + dieListe.einfuegenBei(14, 327); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358)); + dieListe.einfuegenBei(4, 378); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + dieListe.einfuegenBei(30, 620); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546}); + + assertFalse("Fehler: Element 495 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(495)); + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277}); + + assertFalse("Fehler: Element 43 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(43)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277, 589}); + + dieListe.einfuegenBei(11, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277, 589}); + + dieListe.einfuegenBei(44, 290); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 546, 277, 589, 290}); + + dieListe.einfuegenBei(41, 819); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290}); + + assertFalse("Fehler: Element 421 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(421)); + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + dieListe.anhaengen(460); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 460}); + + assertTrue("Fehler: Element 602 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(602)); + assertTrue("Fehler: Element 516 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(516)); + assertTrue("Fehler: Element 687 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(687)); + assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297)); + dieListe.einfuegenBei(29, 65); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 460}); + + dieListe.anhaengen(783); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 460, 783}); + + assertFalse("Fehler: Element 705 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(705)); + dieListe.einfuegenBei(47, 399); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783}); + + dieListe.anhaengen(977); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783, 977}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783, 977, 442}); + + dieListe.einfuegenBei(11, 27); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 460, 783, 977, 442}); + + dieListe.einfuegenBei(49, 32); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442}); + + dieListe.anhaengen(244); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442, 244}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442, 244, 909}); + + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 783, 977, 442, 244, 909, 180}); + + dieListe.einfuegenBei(51, 121); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180}); + + dieListe.einfuegenBei(21, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180}); + + dieListe.anhaengen(698); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698}); + + dieListe.einfuegenBei(5, 440); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698}); + + dieListe.anhaengen(777); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777}); + + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82}); + + dieListe.einfuegenBei(43, 764); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82}); + + dieListe.anhaengen(321); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321}); + + dieListe.anhaengen(545); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545}); + + dieListe.anhaengen(549); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549}); + + dieListe.einfuegenBei(50, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549}); + + assertTrue("Fehler: Element 954 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(954)); + dieListe.einfuegenBei(52, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 572, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 572, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549, 264}); + + dieListe.einfuegenBei(3, 337); + Tester.pruefeListenInhalt(dieListe, new int[]{954, 687, 793, 337, 378, 378, 440, 208, 993, 469, 602, 627, 623, 27, 436, 429, 978, 699, 744, 327, 733, 938, 725, 588, 516, 42, 855, 619, 527, 861, 782, 401, 595, 65, 832, 413, 620, 766, 508, 356, 700, 718, 576, 561, 764, 132, 110, 819, 546, 277, 589, 175, 290, 572, 399, 32, 460, 121, 783, 977, 442, 244, 909, 180, 698, 777, 82, 321, 545, 549, 264}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 9); + Tester.pruefeListenInhalt(dieListe, new int[]{9}); + + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 388}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 388, 990}); + + dieListe.einfuegenBei(0, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 9, 388, 990}); + + assertFalse("Fehler: Element 474 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(474)); + dieListe.einfuegenBei(0, 621); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990}); + + dieListe.einfuegenBei(5, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741}); + + assertFalse("Fehler: Element 30 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(30)); + dieListe.anhaengen(122); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122}); + + dieListe.anhaengen(831); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831}); + + dieListe.einfuegenBei(8, 197); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831, 197}); + + assertTrue("Fehler: Element 990 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(990)); + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831, 197, 257}); + + assertTrue("Fehler: Element 122 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(122)); + assertTrue("Fehler: Element 122 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(122)); + dieListe.anhaengen(882); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 990, 741, 122, 831, 197, 257, 882}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.einfuegenBei(4, 618); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 741, 122, 831, 197, 257, 882}); + + assertTrue("Fehler: Element 882 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(882)); + dieListe.einfuegenBei(10, 964); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 741, 122, 831, 197, 964, 257, 882}); + + dieListe.einfuegenBei(6, 188); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 188, 741, 122, 831, 197, 964, 257, 882}); + + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 188, 741, 122, 831, 197, 964, 257, 882, 357}); + + assertFalse("Fehler: Element 667 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(667)); + dieListe.einfuegenBei(6, 566); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 741, 122, 831, 197, 964, 257, 882, 357}); + + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 741, 122, 831, 197, 964, 257, 882, 357, 207}); + + assertFalse("Fehler: Element 824 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(824)); + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786}); + + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.einfuegenBei(8, 591); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786}); + + dieListe.anhaengen(390); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 413}); + + dieListe.einfuegenBei(20, 864); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297}); + + assertFalse("Fehler: Element 858 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(858)); + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368}); + + assertTrue("Fehler: Element 990 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(990)); + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439}); + + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921}); + + assertFalse("Fehler: Element 982 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(982)); + assertTrue("Fehler: Element 188 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(188)); + dieListe.einfuegenBei(7, 484); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 484, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921}); + + dieListe.einfuegenBei(7, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921}); + + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937}); + + dieListe.einfuegenBei(12, 291); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937}); + + dieListe.anhaengen(829); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937, 829}); + + assertFalse("Fehler: Element 600 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(600)); + assertFalse("Fehler: Element 453 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(453)); + assertTrue("Fehler: Element 937 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(937)); + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + assertFalse("Fehler: Element 988 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(988)); + dieListe.einfuegenBei(23, 905); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(8, 66); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 66, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(9, 196); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(2, 655); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.einfuegenBei(28, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634}); + + dieListe.anhaengen(855); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855}); + + assertFalse("Fehler: Element 164 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(164)); + dieListe.anhaengen(813); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813}); + + assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707)); + dieListe.einfuegenBei(7, 815); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertTrue("Fehler: Element 741 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(741)); + dieListe.einfuegenBei(8, 391); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813}); + + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(901); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901}); + + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + dieListe.einfuegenBei(29, 383); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.einfuegenBei(26, 43); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901}); + + assertFalse("Fehler: Element 504 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(504)); + dieListe.anhaengen(543); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543}); + + assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156)); + assertTrue("Fehler: Element 964 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(964)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395}); + + dieListe.einfuegenBei(10, 800); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437}); + + assertFalse("Fehler: Element 293 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(293)); + dieListe.einfuegenBei(2, 437); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437}); + + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894}); + + dieListe.anhaengen(298); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298}); + + dieListe.einfuegenBei(28, 52); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298}); + + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625}); + + dieListe.anhaengen(548); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883}); + + dieListe.einfuegenBei(21, 714); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883}); + + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894}); + + dieListe.anhaengen(660); + Tester.pruefeListenInhalt(dieListe, new int[]{621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660}); + + dieListe.einfuegenBei(0, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660}); + + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + assertTrue("Fehler: Element 122 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(122)); + dieListe.anhaengen(184); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184}); + + assertTrue("Fehler: Element 188 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(188)); + dieListe.einfuegenBei(37, 411); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184}); + + assertTrue("Fehler: Element 894 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(894)); + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154}); + + assertTrue("Fehler: Element 864 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(864)); + dieListe.einfuegenBei(45, 381); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 381, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154}); + + dieListe.anhaengen(269); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 381, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154, 269}); + + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{539, 621, 553, 437, 655, 9, 388, 618, 990, 815, 391, 566, 800, 707, 66, 196, 484, 188, 591, 741, 291, 122, 714, 831, 197, 964, 257, 882, 357, 207, 52, 43, 786, 390, 905, 383, 864, 411, 360, 413, 297, 368, 439, 921, 937, 381, 829, 634, 855, 813, 901, 543, 395, 437, 894, 298, 625, 548, 883, 894, 660, 184, 154, 269, 769}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{866}); + + assertTrue("Fehler: Element 866 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(866)); + dieListe.einfuegenBei(1, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 555}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); + dieListe.einfuegenBei(1, 303); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 555}); + + assertFalse("Fehler: Element 834 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(834)); + dieListe.einfuegenBei(2, 804); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555}); + + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711}); + + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + dieListe.anhaengen(995); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 995}); + + dieListe.einfuegenBei(5, 295); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995}); + + assertFalse("Fehler: Element 376 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(376)); + dieListe.anhaengen(585); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585}); + + dieListe.anhaengen(113); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113}); + + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 683}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 683, 704}); + + assertTrue("Fehler: Element 585 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(585)); + dieListe.anhaengen(80); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 683, 704, 80}); + + dieListe.einfuegenBei(9, 853); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 853, 683, 704, 80}); + + dieListe.anhaengen(162); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 853, 683, 704, 80, 162}); + + assertTrue("Fehler: Element 295 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(295)); + dieListe.einfuegenBei(11, 407); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162}); + + dieListe.einfuegenBei(4, 166); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450}); + + assertTrue("Fehler: Element 995 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(995)); + assertFalse("Fehler: Element 240 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(240)); + dieListe.anhaengen(859); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859}); + + dieListe.anhaengen(233); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233}); + + dieListe.einfuegenBei(1, 775); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233}); + + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283}); + + dieListe.anhaengen(746); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746}); + + dieListe.anhaengen(481); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746, 481}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746, 481, 974}); + + assertFalse("Fehler: Element 933 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(933)); + dieListe.anhaengen(64); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 233, 283, 746, 481, 974, 64}); + + dieListe.einfuegenBei(19, 721); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64}); + + dieListe.anhaengen(171); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64, 171}); + + dieListe.einfuegenBei(1, 417); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64, 171}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 283, 746, 481, 974, 64, 171, 51}); + + assertTrue("Fehler: Element 804 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(804)); + assertFalse("Fehler: Element 997 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(997)); + dieListe.einfuegenBei(22, 928); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51}); + + dieListe.anhaengen(533); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533}); + + assertFalse("Fehler: Element 744 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(744)); + dieListe.einfuegenBei(31, 423); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423}); + + assertFalse("Fehler: Element 874 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(874)); + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461}); + + dieListe.einfuegenBei(14, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461}); + + dieListe.einfuegenBei(0, 907); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461}); + + assertTrue("Fehler: Element 704 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(704)); + dieListe.anhaengen(872); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225}); + + dieListe.einfuegenBei(16, 306); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225}); + + assertTrue("Fehler: Element 721 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(721)); + assertTrue("Fehler: Element 859 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(859)); + dieListe.einfuegenBei(6, 837); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225, 861}); + + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 461, 872, 225, 861, 608}); + + dieListe.einfuegenBei(36, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 608}); + + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 608, 127}); + + dieListe.einfuegenBei(41, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127}); + + dieListe.einfuegenBei(28, 399); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127}); + + dieListe.einfuegenBei(6, 889); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127}); + + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712}); + + assertTrue("Fehler: Element 866 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(866)); + dieListe.einfuegenBei(29, 314); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712}); + + dieListe.einfuegenBei(7, 253); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712}); + + assertFalse("Fehler: Element 935 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(935)); + assertFalse("Fehler: Element 221 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(221)); + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.einfuegenBei(6, 680); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.einfuegenBei(39, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.einfuegenBei(12, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515}); + + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589}); + + dieListe.anhaengen(509); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + dieListe.einfuegenBei(1, 929); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + assertTrue("Fehler: Element 775 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(775)); + dieListe.einfuegenBei(21, 336); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + assertTrue("Fehler: Element 303 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(303)); + dieListe.einfuegenBei(9, 951); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509}); + + dieListe.einfuegenBei(58, 628); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628}); + + dieListe.anhaengen(713); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.anhaengen(223); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223}); + + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(1, 439); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(6, 693); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(52, 219); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(51, 444); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.einfuegenBei(52, 908); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45}); + + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263}); + + assertFalse("Fehler: Element 665 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(665)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226}); + + dieListe.anhaengen(48); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48}); + + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251}); + + dieListe.einfuegenBei(0, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{462, 907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251}); + + dieListe.anhaengen(350); + Tester.pruefeListenInhalt(dieListe, new int[]{462, 907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251, 350}); + + dieListe.einfuegenBei(1, 773); + Tester.pruefeListenInhalt(dieListe, new int[]{462, 773, 907, 439, 929, 866, 417, 775, 693, 303, 804, 680, 889, 951, 253, 837, 555, 166, 613, 711, 295, 995, 585, 113, 853, 683, 336, 702, 306, 407, 704, 80, 162, 450, 859, 721, 233, 928, 283, 314, 399, 746, 481, 974, 64, 171, 51, 238, 533, 423, 536, 461, 872, 444, 908, 225, 219, 861, 109, 608, 127, 712, 515, 589, 509, 628, 713, 990, 223, 45, 263, 226, 48, 251, 350}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 619); + Tester.pruefeListenInhalt(dieListe, new int[]{619}); + + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{619, 168}); + + assertTrue("Fehler: Element 168 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(168)); + dieListe.einfuegenBei(2, 199); + Tester.pruefeListenInhalt(dieListe, new int[]{619, 168, 199}); + + assertTrue("Fehler: Element 168 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(168)); + dieListe.anhaengen(202); + Tester.pruefeListenInhalt(dieListe, new int[]{619, 168, 199, 202}); + + dieListe.einfuegenBei(0, 326); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202}); + + dieListe.einfuegenBei(5, 747); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747, 194}); + + assertTrue("Fehler: Element 202 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(202)); + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + assertFalse("Fehler: Element 228 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(228)); + assertTrue("Fehler: Element 326 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(326)); + assertFalse("Fehler: Element 431 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(431)); + assertTrue("Fehler: Element 326 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(326)); + dieListe.anhaengen(243); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747, 194, 243}); + + dieListe.anhaengen(798); + Tester.pruefeListenInhalt(dieListe, new int[]{326, 619, 168, 199, 202, 747, 194, 243, 798}); + + dieListe.einfuegenBei(0, 76); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 747, 194, 243, 798}); + + dieListe.anhaengen(67); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 747, 194, 243, 798, 67}); + + dieListe.einfuegenBei(6, 455); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 455, 747, 194, 243, 798, 67}); + + dieListe.anhaengen(895); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 455, 747, 194, 243, 798, 67, 895}); + + assertFalse("Fehler: Element 524 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(524)); + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + assertFalse("Fehler: Element 450 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(450)); + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + dieListe.anhaengen(289); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 455, 747, 194, 243, 798, 67, 895, 289}); + + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + assertTrue("Fehler: Element 798 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(798)); + dieListe.einfuegenBei(6, 160); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289, 852}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289, 852, 644}); + + dieListe.einfuegenBei(1, 807); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 67, 895, 289, 852, 644}); + + assertFalse("Fehler: Element 856 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(856)); + dieListe.einfuegenBei(13, 808); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 160, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644}); + + assertFalse("Fehler: Element 233 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(233)); + dieListe.einfuegenBei(8, 284); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644}); + + dieListe.einfuegenBei(7, 96); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644}); + + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 482}); + + dieListe.anhaengen(892); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 482, 892}); + + dieListe.einfuegenBei(21, 287); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892}); + + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383}); + + dieListe.einfuegenBei(14, 501); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383}); + + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627}); + + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251, 442}); + + dieListe.anhaengen(803); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251, 442, 803}); + + assertFalse("Fehler: Element 696 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(696)); + dieListe.anhaengen(820); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 287, 482, 892, 383, 627, 251, 442, 803, 820}); + + dieListe.einfuegenBei(22, 541); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 892, 383, 627, 251, 442, 803, 820}); + + dieListe.anhaengen(188); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 892, 383, 627, 251, 442, 803, 820, 188}); + + dieListe.einfuegenBei(25, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188}); + + dieListe.einfuegenBei(12, 242); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188}); + + assertFalse("Fehler: Element 987 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(987)); + assertTrue("Fehler: Element 202 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(202)); + assertFalse("Fehler: Element 731 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(731)); + assertFalse("Fehler: Element 57 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(57)); + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89}); + + dieListe.einfuegenBei(2, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89}); + + assertFalse("Fehler: Element 788 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(788)); + dieListe.einfuegenBei(11, 667); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89}); + + dieListe.anhaengen(755); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755}); + + assertFalse("Fehler: Element 812 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(812)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + dieListe.einfuegenBei(25, 824); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755}); + + dieListe.einfuegenBei(2, 550); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755}); + + dieListe.anhaengen(524); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524}); + + assertTrue("Fehler: Element 242 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(242)); + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219}); + + assertFalse("Fehler: Element 8 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(8)); + dieListe.einfuegenBei(2, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219}); + + dieListe.anhaengen(298); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211}); + + dieListe.einfuegenBei(8, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211}); + + dieListe.anhaengen(587); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211, 587}); + + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 89, 755, 524, 219, 298, 211, 587, 615}); + + dieListe.einfuegenBei(41, 642); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615}); + + dieListe.anhaengen(996); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996}); + + assertTrue("Fehler: Element 67 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(67)); + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996, 39}); + + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996, 39, 7}); + + assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892)); + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(44, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(9, 544); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 544, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(36, 461); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 807, 77, 550, 568, 326, 619, 168, 416, 544, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.einfuegenBei(1, 997); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + assertFalse("Fehler: Element 310 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(310)); + dieListe.einfuegenBei(11, 437); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275}); + + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708}); + + assertFalse("Fehler: Element 428 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(428)); + dieListe.einfuegenBei(28, 548); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708}); + + dieListe.anhaengen(467); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467}); + + dieListe.einfuegenBei(48, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467}); + + assertFalse("Fehler: Element 628 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(628)); + dieListe.einfuegenBei(12, 645); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467}); + + assertFalse("Fehler: Element 247 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(247)); + dieListe.anhaengen(654); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467, 654}); + + dieListe.einfuegenBei(43, 309); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 309, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467, 654}); + + dieListe.anhaengen(240); + Tester.pruefeListenInhalt(dieListe, new int[]{76, 997, 807, 77, 550, 568, 326, 619, 168, 416, 544, 437, 645, 199, 202, 96, 160, 284, 667, 455, 747, 242, 194, 243, 501, 798, 808, 67, 895, 548, 289, 852, 644, 824, 541, 287, 482, 447, 892, 383, 461, 627, 251, 309, 442, 803, 820, 188, 642, 89, 157, 755, 569, 524, 219, 298, 211, 587, 615, 996, 39, 7, 275, 708, 467, 654, 240}); + + assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest5.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest5.java new file mode 100644 index 0000000..f2be0d0 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest5.java @@ -0,0 +1,2397 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest5. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest5 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{86}); + + assertTrue("Fehler: Element 86 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(86)); + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 145}); + + assertTrue("Fehler: Element 86 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 169 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(169)); + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 145, 788}); + + assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477)); + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.einfuegenBei(1, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 991, 145, 788}); + + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.einfuegenBei(4, 931); + Tester.pruefeListenInhalt(dieListe, new int[]{86, 991, 145, 788, 931}); + + assertFalse("Fehler: Element 611 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(611)); + dieListe.einfuegenBei(0, 201); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 991, 145, 788, 931}); + + dieListe.einfuegenBei(2, 153); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931}); + + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 69}); + + dieListe.einfuegenBei(7, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69}); + + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 297}); + + dieListe.einfuegenBei(9, 147); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 147, 297}); + + dieListe.anhaengen(963); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 147, 297, 963}); + + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334}); + + dieListe.einfuegenBei(3, 972); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334}); + + dieListe.anhaengen(842); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334, 842}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 963, 334, 842, 267}); + + assertFalse("Fehler: Element 682 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(682)); + dieListe.einfuegenBei(12, 275); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758, 341}); + + dieListe.anhaengen(233); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758, 341, 233}); + + dieListe.anhaengen(819); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 334, 842, 267, 758, 341, 233, 819}); + + dieListe.einfuegenBei(14, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 853}); + + assertTrue("Fehler: Element 334 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(334)); + assertFalse("Fehler: Element 401 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(401)); + dieListe.einfuegenBei(8, 859); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 853}); + + assertFalse("Fehler: Element 623 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(623)); + assertTrue("Fehler: Element 275 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(275)); + assertFalse("Fehler: Element 645 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(645)); + dieListe.anhaengen(804); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 853, 804}); + + assertTrue("Fehler: Element 233 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(233)); + dieListe.einfuegenBei(23, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 59, 853, 804}); + + dieListe.einfuegenBei(23, 285); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 267, 758, 341, 233, 819, 285, 59, 853, 804}); + + dieListe.einfuegenBei(18, 283); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675}); + + dieListe.anhaengen(547); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547}); + + assertFalse("Fehler: Element 589 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(589)); + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972}); + + assertFalse("Fehler: Element 453 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(453)); + dieListe.anhaengen(991); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 991}); + + dieListe.einfuegenBei(13, 197); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 991}); + + dieListe.einfuegenBei(33, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 360, 991}); + + assertFalse("Fehler: Element 744 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(744)); + dieListe.anhaengen(177); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 360, 991, 177}); + + assertFalse("Fehler: Element 497 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(497)); + dieListe.einfuegenBei(1, 31); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 360, 991, 177}); + + dieListe.einfuegenBei(34, 934); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177}); + + dieListe.anhaengen(770); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770}); + + dieListe.anhaengen(339); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339}); + + dieListe.anhaengen(513); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339, 513}); + + assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486)); + dieListe.anhaengen(937); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339, 513, 937}); + + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 934, 360, 991, 177, 770, 339, 513, 937, 348}); + + dieListe.einfuegenBei(34, 254); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348}); + + assertFalse("Fehler: Element 402 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(402)); + dieListe.einfuegenBei(14, 211); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 211, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 859, 713, 69, 147, 297, 211, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.einfuegenBei(9, 951); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.einfuegenBei(19, 655); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + assertFalse("Fehler: Element 557 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(557)); + dieListe.einfuegenBei(24, 522); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.einfuegenBei(7, 738); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302}); + + dieListe.anhaengen(972); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302, 972}); + + dieListe.einfuegenBei(3, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 302, 972}); + + dieListe.einfuegenBei(50, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972}); + + dieListe.anhaengen(834); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834}); + + dieListe.anhaengen(269); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269}); + + assertFalse("Fehler: Element 784 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(784)); + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894}); + + assertFalse("Fehler: Element 442 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(442)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226}); + + assertFalse("Fehler: Element 883 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(883)); + dieListe.anhaengen(495); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495}); + + dieListe.einfuegenBei(18, 808); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495}); + + dieListe.einfuegenBei(2, 811); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495}); + + dieListe.anhaengen(462); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462}); + + dieListe.einfuegenBei(30, 809); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462}); + + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.anhaengen(52); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52}); + + assertTrue("Fehler: Element 972 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(972)); + dieListe.einfuegenBei(46, 982); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52}); + + dieListe.einfuegenBei(5, 117); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347}); + + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347, 867}); + + dieListe.einfuegenBei(20, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347, 867}); + + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 52, 347, 867, 822}); + + dieListe.einfuegenBei(65, 295); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 295, 52, 347, 867, 822}); + + dieListe.anhaengen(849); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 295, 52, 347, 867, 822, 849}); + + dieListe.anhaengen(447); + Tester.pruefeListenInhalt(dieListe, new int[]{201, 31, 811, 86, 36, 117, 153, 972, 991, 145, 738, 788, 931, 951, 859, 713, 69, 147, 297, 211, 778, 808, 197, 275, 963, 655, 702, 334, 842, 283, 522, 267, 809, 758, 341, 233, 819, 285, 59, 853, 804, 305, 675, 547, 972, 254, 934, 360, 982, 991, 177, 770, 339, 513, 937, 348, 922, 302, 972, 834, 269, 894, 226, 495, 462, 295, 52, 347, 867, 822, 849, 447}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{688}); + + dieListe.einfuegenBei(1, 958); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958}); + + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958, 672}); + + assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672)); + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958, 672, 816}); + + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 958, 672, 816, 797}); + + assertTrue("Fehler: Element 797 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(797)); + dieListe.einfuegenBei(0, 316); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 672, 816, 797}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 672, 816, 797, 469}); + + assertFalse("Fehler: Element 549 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(549)); + dieListe.einfuegenBei(3, 408); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469}); + + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 271}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 271, 679}); + + dieListe.einfuegenBei(8, 18); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 18, 271, 679}); + + dieListe.einfuegenBei(9, 899); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 18, 899, 271, 679}); + + dieListe.einfuegenBei(12, 761); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 18, 899, 271, 679, 761}); + + dieListe.einfuegenBei(8, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 679, 761}); + + dieListe.einfuegenBei(14, 112); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 679, 761, 112}); + + dieListe.einfuegenBei(12, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 112}); + + dieListe.einfuegenBei(2, 952); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 112}); + + assertTrue("Fehler: Element 316 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(316)); + assertFalse("Fehler: Element 136 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(136)); + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.einfuegenBei(16, 235); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 235, 112}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 235, 112, 411}); + + dieListe.einfuegenBei(5, 583); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 899, 271, 239, 679, 761, 235, 112, 411}); + + dieListe.einfuegenBei(12, 187); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 235, 112, 411}); + + dieListe.anhaengen(717); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 235, 112, 411, 717}); + + dieListe.einfuegenBei(18, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717}); + + dieListe.anhaengen(177); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717, 177}); + + dieListe.anhaengen(814); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717, 177, 814}); + + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 761, 82, 235, 112, 411, 717, 177, 814, 487}); + + dieListe.einfuegenBei(17, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487}); + + dieListe.anhaengen(205); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205}); + + dieListe.einfuegenBei(11, 999); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205}); + + assertFalse("Fehler: Element 101 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(101)); + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194}); + + dieListe.einfuegenBei(19, 690); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194}); + + dieListe.einfuegenBei(8, 735); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194}); + + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812}); + + assertFalse("Fehler: Element 957 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(957)); + dieListe.einfuegenBei(16, 204); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812}); + + dieListe.anhaengen(563); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812, 563}); + + dieListe.einfuegenBei(13, 597); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812, 563}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + dieListe.anhaengen(323); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 205, 194, 812, 563, 323}); + + dieListe.einfuegenBei(32, 892); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323}); + + assertFalse("Fehler: Element 366 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(366)); + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77}); + + dieListe.anhaengen(237); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237}); + + dieListe.anhaengen(781); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.einfuegenBei(14, 286); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.einfuegenBei(9, 290); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.einfuegenBei(4, 279); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781}); + + dieListe.anhaengen(18); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 205, 194, 812, 563, 323, 77, 237, 781, 18}); + + assertTrue("Fehler: Element 408 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(408)); + dieListe.einfuegenBei(36, 228); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18}); + + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18, 290}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18, 290, 576}); + + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604}); + + dieListe.einfuegenBei(39, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604}); + + assertTrue("Fehler: Element 604 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(604)); + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + dieListe.einfuegenBei(10, 320); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958}); + + dieListe.anhaengen(252); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646}); + + dieListe.einfuegenBei(33, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646}); + + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767}); + + assertFalse("Fehler: Element 389 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(389)); + dieListe.anhaengen(161); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161}); + + assertTrue("Fehler: Element 767 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(767)); + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + dieListe.einfuegenBei(29, 971); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161}); + + dieListe.anhaengen(459); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459}); + + assertTrue("Fehler: Element 583 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(583)); + dieListe.anhaengen(35); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35}); + + assertFalse("Fehler: Element 501 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(501)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191}); + + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606}); + + dieListe.anhaengen(556); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556}); + + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812}); + + dieListe.anhaengen(993); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993}); + + assertTrue("Fehler: Element 812 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(812)); + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + dieListe.einfuegenBei(4, 475); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619}); + + assertFalse("Fehler: Element 123 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(123)); + dieListe.einfuegenBei(24, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619}); + + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + dieListe.einfuegenBei(6, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 380, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + dieListe.einfuegenBei(48, 639); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 380, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 814, 487, 892, 228, 205, 194, 920, 812, 563, 639, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + assertFalse("Fehler: Element 392 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(392)); + assertFalse("Fehler: Element 817 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(817)); + dieListe.einfuegenBei(39, 49); + Tester.pruefeListenInhalt(dieListe, new int[]{316, 688, 952, 958, 475, 279, 380, 408, 583, 672, 816, 735, 320, 290, 797, 469, 183, 999, 597, 286, 18, 187, 899, 204, 271, 382, 239, 679, 688, 690, 761, 82, 971, 235, 112, 411, 717, 813, 177, 49, 814, 487, 892, 228, 205, 194, 920, 812, 563, 639, 323, 77, 237, 781, 18, 290, 576, 604, 958, 252, 646, 767, 161, 459, 35, 191, 606, 556, 812, 993, 619, 749}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{328}); + + dieListe.einfuegenBei(1, 224); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 224}); + + dieListe.anhaengen(431); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 224, 431}); + + dieListe.anhaengen(936); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 224, 431, 936}); + + dieListe.einfuegenBei(1, 399); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 431, 936}); + + dieListe.anhaengen(424); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 431, 936, 424}); + + dieListe.einfuegenBei(3, 844); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424}); + + dieListe.anhaengen(486); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486}); + + dieListe.anhaengen(60); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486, 60}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486, 60, 581}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 431, 936, 424, 486, 60, 581, 664}); + + dieListe.einfuegenBei(4, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 486, 60, 581, 664}); + + dieListe.einfuegenBei(8, 488); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664, 845}); + + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725}); + + dieListe.anhaengen(830); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + dieListe.einfuegenBei(5, 728); + Tester.pruefeListenInhalt(dieListe, new int[]{328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + assertTrue("Fehler: Element 936 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(936)); + dieListe.einfuegenBei(0, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{798, 328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + assertTrue("Fehler: Element 725 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(725)); + dieListe.einfuegenBei(0, 786); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830}); + + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 816}); + + assertTrue("Fehler: Element 424 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(424)); + dieListe.einfuegenBei(3, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 816}); + + assertFalse("Fehler: Element 528 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(528)); + assertFalse("Fehler: Element 540 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(540)); + dieListe.einfuegenBei(20, 869); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 869, 816}); + + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 725, 830, 869, 816, 954}); + + dieListe.einfuegenBei(18, 153); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954}); + + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633}); + + assertTrue("Fehler: Element 830 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(830)); + dieListe.einfuegenBei(4, 946); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633}); + + dieListe.einfuegenBei(3, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633}); + + assertTrue("Fehler: Element 60 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(60)); + dieListe.anhaengen(665); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665}); + + dieListe.anhaengen(851); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851}); + + assertFalse("Fehler: Element 305 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(305)); + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312}); + + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312, 595}); + + dieListe.einfuegenBei(2, 213); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312, 595}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 851, 312, 595, 247}); + + dieListe.einfuegenBei(29, 294); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247}); + + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536}); + + dieListe.anhaengen(322); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322}); + + dieListe.anhaengen(524); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852}); + + assertTrue("Fehler: Element 399 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(399)); + dieListe.einfuegenBei(14, 181); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852}); + + dieListe.einfuegenBei(25, 585); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852}); + + assertTrue("Fehler: Element 852 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(852)); + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121}); + + assertFalse("Fehler: Element 343 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(343)); + dieListe.einfuegenBei(12, 431); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121}); + + dieListe.einfuegenBei(10, 493); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121, 539}); + + assertFalse("Fehler: Element 532 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(532)); + dieListe.einfuegenBei(33, 563); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121, 539}); + + dieListe.anhaengen(980); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 121, 539, 980}); + + assertTrue("Fehler: Element 328 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(328)); + dieListe.einfuegenBei(43, 856); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980}); + + dieListe.anhaengen(167); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 167}); + + dieListe.einfuegenBei(34, 700); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 167}); + + dieListe.einfuegenBei(48, 977); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.einfuegenBei(1, 592); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + assertTrue("Fehler: Element 830 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(830)); + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + dieListe.einfuegenBei(24, 684); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 488, 486, 60, 581, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + dieListe.einfuegenBei(19, 401); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + dieListe.einfuegenBei(24, 737); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 121, 539, 980, 977, 167}); + + assertFalse("Fehler: Element 987 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(987)); + dieListe.einfuegenBei(49, 675); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347}); + + dieListe.einfuegenBei(6, 897); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347}); + + dieListe.anhaengen(517); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + assertTrue("Fehler: Element 665 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(665)); + dieListe.einfuegenBei(28, 793); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + dieListe.einfuegenBei(16, 616); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + assertTrue("Fehler: Element 224 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(224)); + dieListe.einfuegenBei(13, 279); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517}); + + dieListe.anhaengen(785); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785}); + + dieListe.einfuegenBei(37, 104); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785}); + + dieListe.anhaengen(398); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398}); + + assertTrue("Fehler: Element 424 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(424)); + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + assertFalse("Fehler: Element 222 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(222)); + dieListe.anhaengen(173); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173}); + + dieListe.einfuegenBei(34, 107); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173}); + + assertTrue("Fehler: Element 213 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(213)); + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699}); + + dieListe.einfuegenBei(51, 209); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699}); + + dieListe.einfuegenBei(6, 902); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699}); + + assertTrue("Fehler: Element 539 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(539)); + assertTrue("Fehler: Element 60 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(60)); + assertTrue("Fehler: Element 946 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(946)); + dieListe.anhaengen(119); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119}); + + dieListe.einfuegenBei(15, 870); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 870, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119}); + + assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52)); + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 870, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119, 992}); + + dieListe.anhaengen(514); + Tester.pruefeListenInhalt(dieListe, new int[]{786, 592, 798, 213, 328, 736, 902, 897, 157, 946, 399, 224, 844, 493, 279, 870, 702, 728, 431, 616, 431, 936, 181, 424, 401, 488, 486, 60, 581, 737, 664, 684, 793, 845, 153, 725, 107, 830, 585, 869, 104, 816, 954, 633, 665, 563, 700, 294, 851, 312, 595, 247, 536, 209, 322, 524, 852, 856, 675, 121, 539, 980, 977, 167, 347, 517, 785, 398, 173, 699, 119, 992, 514}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 25); + Tester.pruefeListenInhalt(dieListe, new int[]{25}); + + dieListe.anhaengen(550); + Tester.pruefeListenInhalt(dieListe, new int[]{25, 550}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{25, 550, 359}); + + assertFalse("Fehler: Element 571 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(571)); + assertTrue("Fehler: Element 25 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(25)); + dieListe.einfuegenBei(0, 671); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 25, 550, 359}); + + dieListe.anhaengen(425); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 25, 550, 359, 425}); + + dieListe.einfuegenBei(1, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 880, 25, 550, 359, 425}); + + assertFalse("Fehler: Element 955 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(955)); + dieListe.einfuegenBei(3, 478); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 880, 25, 478, 550, 359, 425}); + + dieListe.einfuegenBei(4, 284); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 880, 25, 478, 284, 550, 359, 425}); + + dieListe.einfuegenBei(1, 776); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 880, 25, 478, 284, 550, 359, 425}); + + dieListe.einfuegenBei(2, 928); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425}); + + assertFalse("Fehler: Element 174 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(174)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395}); + + assertFalse("Fehler: Element 830 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(830)); + assertTrue("Fehler: Element 284 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(284)); + dieListe.anhaengen(551); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395, 551}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395, 551, 874}); + + dieListe.anhaengen(819); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 359, 425, 395, 551, 874, 819}); + + dieListe.einfuegenBei(8, 406); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 425, 395, 551, 874, 819}); + + dieListe.einfuegenBei(12, 989); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 425, 395, 989, 551, 874, 819}); + + dieListe.anhaengen(235); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 425, 395, 989, 551, 874, 819, 235}); + + dieListe.einfuegenBei(10, 340); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 359, 340, 425, 395, 989, 551, 874, 819, 235}); + + dieListe.einfuegenBei(9, 422); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + dieListe.anhaengen(140); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186}); + + assertFalse("Fehler: Element 514 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(514)); + dieListe.anhaengen(522); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186, 522}); + + assertFalse("Fehler: Element 540 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(540)); + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186, 522, 921}); + + dieListe.einfuegenBei(10, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 396, 359, 340, 425, 395, 989, 551, 874, 819, 235, 140, 186, 522, 921}); + + assertFalse("Fehler: Element 938 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(938)); + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + dieListe.einfuegenBei(19, 10); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 396, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + dieListe.einfuegenBei(11, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 550, 406, 422, 396, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + dieListe.einfuegenBei(7, 318); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 318, 550, 406, 422, 396, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + assertTrue("Fehler: Element 318 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(318)); + dieListe.einfuegenBei(12, 308); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.einfuegenBei(7, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 284, 599, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.einfuegenBei(6, 660); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 318, 550, 406, 422, 396, 308, 539, 359, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.einfuegenBei(17, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + assertFalse("Fehler: Element 499 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(499)); + assertFalse("Fehler: Element 997 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(997)); + dieListe.einfuegenBei(9, 49); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507}); + + assertTrue("Fehler: Element 235 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(235)); + assertFalse("Fehler: Element 89 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(89)); + dieListe.einfuegenBei(34, 393); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507, 393}); + + dieListe.anhaengen(836); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507, 393, 836}); + + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 921, 411, 507, 393, 836, 23}); + + assertTrue("Fehler: Element 422 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(422)); + dieListe.einfuegenBei(31, 621); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 23}); + + assertFalse("Fehler: Element 771 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(771)); + dieListe.anhaengen(925); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 23, 925}); + + dieListe.einfuegenBei(24, 67); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 23, 925}); + + dieListe.einfuegenBei(38, 832); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 832, 23, 925}); + + assertFalse("Fehler: Element 435 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(435)); + dieListe.anhaengen(162); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 393, 836, 832, 23, 925, 162}); + + dieListe.einfuegenBei(36, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162}); + + dieListe.einfuegenBei(31, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162}); + + dieListe.anhaengen(754); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754}); + + dieListe.anhaengen(439); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439}); + + dieListe.einfuegenBei(20, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439}); + + dieListe.anhaengen(597); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597}); + + dieListe.einfuegenBei(31, 485); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351}); + + assertTrue("Fehler: Element 874 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(874)); + dieListe.einfuegenBei(35, 779); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351}); + + dieListe.anhaengen(405); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405}); + + dieListe.einfuegenBei(24, 576); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405}); + + assertTrue("Fehler: Element 406 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(406)); + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575}); + + assertFalse("Fehler: Element 512 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(512)); + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.einfuegenBei(23, 857); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575}); + + dieListe.anhaengen(697); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697}); + + assertFalse("Fehler: Element 57 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(57)); + dieListe.anhaengen(354); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354}); + + assertTrue("Fehler: Element 597 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(597)); + assertTrue("Fehler: Element 162 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(162)); + dieListe.einfuegenBei(15, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354}); + + assertFalse("Fehler: Element 139 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(139)); + dieListe.anhaengen(207); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 207}); + + assertFalse("Fehler: Element 191 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(191)); + dieListe.einfuegenBei(58, 190); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207}); + + dieListe.einfuegenBei(37, 358); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207}); + + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + dieListe.einfuegenBei(3, 716); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207}); + + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434}); + + dieListe.anhaengen(845); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845}); + + dieListe.anhaengen(249); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845, 249}); + + dieListe.einfuegenBei(44, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 874, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845, 249}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{671, 776, 928, 716, 880, 25, 478, 660, 284, 599, 49, 318, 550, 406, 422, 396, 990, 308, 539, 359, 568, 340, 281, 425, 395, 857, 989, 576, 551, 67, 874, 819, 10, 235, 140, 485, 186, 980, 358, 522, 779, 621, 921, 411, 874, 507, 183, 393, 836, 832, 23, 925, 162, 754, 439, 597, 351, 405, 575, 697, 354, 190, 207, 434, 845, 249, 557}); + + assertTrue("Fehler: Element 67 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(67)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{442}); + + dieListe.einfuegenBei(0, 475); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442}); + + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474}); + + dieListe.anhaengen(8); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8}); + + dieListe.anhaengen(921); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921}); + + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921, 786}); + + assertFalse("Fehler: Element 885 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(885)); + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921, 786, 570}); + + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 442, 474, 8, 921, 786, 570, 263}); + + dieListe.einfuegenBei(1, 865); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 474, 8, 921, 786, 570, 263}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 474, 8, 921, 786, 570, 263, 315}); + + dieListe.einfuegenBei(3, 128); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 128, 474, 8, 921, 786, 570, 263, 315}); + + dieListe.einfuegenBei(3, 892); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 8, 921, 786, 570, 263, 315}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 8, 921, 786, 570, 263, 315, 502}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 8, 921, 786, 570, 263, 315, 502, 626}); + + assertTrue("Fehler: Element 475 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(475)); + assertFalse("Fehler: Element 312 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(312)); + assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892)); + assertTrue("Fehler: Element 442 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(442)); + assertTrue("Fehler: Element 8 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(8)); + dieListe.einfuegenBei(6, 68); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 263, 315, 502, 626}); + + dieListe.anhaengen(493); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 263, 315, 502, 626, 493}); + + dieListe.anhaengen(232); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 263, 315, 502, 626, 493, 232}); + + assertTrue("Fehler: Element 263 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(263)); + dieListe.einfuegenBei(11, 923); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 263, 315, 502, 626, 493, 232}); + + dieListe.einfuegenBei(18, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 263, 315, 502, 626, 493, 232, 467}); + + assertTrue("Fehler: Element 570 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(570)); + assertTrue("Fehler: Element 315 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(315)); + dieListe.anhaengen(240); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 263, 315, 502, 626, 493, 232, 467, 240}); + + dieListe.einfuegenBei(12, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 232, 467, 240}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 232, 467, 240, 262}); + + assertFalse("Fehler: Element 879 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(879)); + assertTrue("Fehler: Element 442 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(442)); + assertFalse("Fehler: Element 488 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(488)); + dieListe.einfuegenBei(18, 54); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 54, 232, 467, 240, 262}); + + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 315, 502, 626, 493, 54, 232, 467, 240, 262, 922}); + + dieListe.einfuegenBei(14, 895); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 232, 467, 240, 262, 922}); + + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 232, 467, 240, 262, 922, 302}); + + dieListe.einfuegenBei(20, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539}); + + dieListe.einfuegenBei(17, 102); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539}); + + dieListe.einfuegenBei(5, 943); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539}); + + assertFalse("Fehler: Element 72 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(72)); + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); + assertTrue("Fehler: Element 539 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(539)); + dieListe.anhaengen(603); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603}); + + dieListe.anhaengen(886); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886}); + + dieListe.anhaengen(658); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658}); + + dieListe.anhaengen(72); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72}); + + dieListe.einfuegenBei(18, 127); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 127, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72}); + + dieListe.anhaengen(808); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 127, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72, 808}); + + dieListe.einfuegenBei(19, 704); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72, 808}); + + dieListe.einfuegenBei(12, 905); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 603, 886, 658, 72, 808}); + + dieListe.einfuegenBei(34, 241); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808}); + + assertFalse("Fehler: Element 801 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(801)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286}); + + dieListe.einfuegenBei(25, 802); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286}); + + dieListe.anhaengen(20); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20}); + + dieListe.anhaengen(374); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374}); + + dieListe.anhaengen(579); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579}); + + dieListe.anhaengen(917); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579, 917}); + + assertTrue("Fehler: Element 54 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(54)); + assertFalse("Fehler: Element 32 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(32)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72)); + dieListe.anhaengen(580); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579, 917, 580}); + + dieListe.anhaengen(600); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 20, 374, 579, 917, 580, 600}); + + dieListe.einfuegenBei(42, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600}); + + dieListe.einfuegenBei(13, 179); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600}); + + assertFalse("Fehler: Element 277 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(277)); + assertFalse("Fehler: Element 654 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(654)); + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521}); + + assertTrue("Fehler: Element 603 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(603)); + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22}); + + dieListe.einfuegenBei(34, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22}); + + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799}); + + assertFalse("Fehler: Element 827 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(827)); + dieListe.einfuegenBei(28, 690); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799}); + + assertTrue("Fehler: Element 128 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(128)); + assertFalse("Fehler: Element 590 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(590)); + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881}); + + dieListe.einfuegenBei(18, 821); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881}); + + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881, 369}); + + dieListe.anhaengen(158); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881, 369, 158}); + + dieListe.anhaengen(228); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 881, 369, 158, 228}); + + dieListe.einfuegenBei(56, 538); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228}); + + assertTrue("Fehler: Element 179 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(179)); + assertTrue("Fehler: Element 580 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(580)); + dieListe.einfuegenBei(38, 412); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228}); + + dieListe.anhaengen(181); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181}); + + assertTrue("Fehler: Element 865 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(865)); + assertTrue("Fehler: Element 579 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(579)); + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854}); + + assertTrue("Fehler: Element 475 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(475)); + dieListe.anhaengen(56); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56}); + + dieListe.anhaengen(582); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56, 582}); + + dieListe.einfuegenBei(41, 677); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 677, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56, 582}); + + assertTrue("Fehler: Element 228 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(228)); + dieListe.anhaengen(352); + Tester.pruefeListenInhalt(dieListe, new int[]{475, 865, 442, 892, 128, 943, 474, 68, 8, 921, 786, 570, 905, 179, 923, 218, 263, 895, 821, 315, 502, 127, 704, 102, 626, 493, 54, 802, 651, 690, 232, 467, 240, 262, 922, 302, 368, 292, 412, 539, 241, 677, 603, 886, 658, 72, 808, 286, 588, 20, 374, 579, 917, 580, 600, 521, 22, 799, 538, 881, 369, 158, 228, 181, 854, 56, 582, 352}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(744); + Tester.pruefeListenInhalt(dieListe, new int[]{744}); + + dieListe.einfuegenBei(0, 168); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 793}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 793, 957}); + + dieListe.einfuegenBei(2, 275); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957, 529}); + + dieListe.anhaengen(969); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957, 529, 969}); + + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 744, 275, 793, 957, 529, 969, 625}); + + dieListe.einfuegenBei(1, 570); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625}); + + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 434}); + + assertFalse("Fehler: Element 82 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(82)); + dieListe.einfuegenBei(9, 634); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 634, 434}); + + dieListe.einfuegenBei(9, 56); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 56, 634, 434}); + + dieListe.einfuegenBei(11, 646); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 56, 634, 646, 434}); + + dieListe.anhaengen(274); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 625, 56, 634, 646, 434, 274}); + + dieListe.einfuegenBei(8, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274}); + + dieListe.anhaengen(396); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396}); + + assertTrue("Fehler: Element 625 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(625)); + dieListe.anhaengen(32); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32}); + + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793}); + + dieListe.einfuegenBei(18, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 413}); + + dieListe.anhaengen(948); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 413, 948}); + + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + dieListe.einfuegenBei(18, 514); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 514, 413, 948}); + + dieListe.anhaengen(85); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 396, 32, 793, 514, 413, 948, 85}); + + dieListe.einfuegenBei(15, 596); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85}); + + assertFalse("Fehler: Element 142 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(142)); + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + assertTrue("Fehler: Element 793 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(793)); + assertFalse("Fehler: Element 517 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(517)); + assertTrue("Fehler: Element 435 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(435)); + dieListe.anhaengen(638); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638}); + + assertTrue("Fehler: Element 168 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(168)); + dieListe.einfuegenBei(24, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842}); + + dieListe.einfuegenBei(3, 882); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842}); + + assertTrue("Fehler: Element 434 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(434)); + assertTrue("Fehler: Element 744 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(744)); + dieListe.einfuegenBei(26, 577); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577}); + + dieListe.einfuegenBei(7, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577, 521}); + + dieListe.anhaengen(605); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.einfuegenBei(23, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 274, 596, 396, 32, 793, 514, 413, 758, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.einfuegenBei(16, 768); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 758, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.einfuegenBei(24, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605}); + + assertFalse("Fehler: Element 363 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(363)); + assertFalse("Fehler: Element 706 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(706)); + assertTrue("Fehler: Element 275 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(275)); + assertTrue("Fehler: Element 744 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(744)); + dieListe.einfuegenBei(7, 802); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605}); + + dieListe.anhaengen(841); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605, 841}); + + assertTrue("Fehler: Element 85 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(85)); + dieListe.einfuegenBei(18, 653); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 948, 85, 638, 842, 577, 521, 605, 841}); + + dieListe.einfuegenBei(28, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841}); + + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620}); + + assertFalse("Fehler: Element 348 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(348)); + assertFalse("Fehler: Element 437 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(829); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829}); + + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + assertTrue("Fehler: Element 842 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(842)); + dieListe.einfuegenBei(5, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829}); + + dieListe.einfuegenBei(12, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829}); + + assertTrue("Fehler: Element 634 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(634)); + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967}); + + dieListe.anhaengen(50); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50}); + + dieListe.anhaengen(705); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705}); + + dieListe.einfuegenBei(23, 125); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705}); + + dieListe.einfuegenBei(45, 670); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670}); + + dieListe.einfuegenBei(17, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670}); + + dieListe.anhaengen(787); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787}); + + assertTrue("Fehler: Element 435 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(435)); + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686}); + + dieListe.anhaengen(795); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795}); + + dieListe.anhaengen(733); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795, 733}); + + dieListe.einfuegenBei(14, 209); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795, 733}); + + assertTrue("Fehler: Element 829 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(829)); + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + dieListe.einfuegenBei(25, 834); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 967, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 294 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(294)); + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + dieListe.einfuegenBei(45, 584); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 584, 967, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 502 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(502)); + dieListe.einfuegenBei(47, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 696 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(696)); + assertTrue("Fehler: Element 56 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(56)); + dieListe.einfuegenBei(2, 269); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertFalse("Fehler: Element 388 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 144 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(144)); + assertFalse("Fehler: Element 106 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(106)); + dieListe.einfuegenBei(41, 139); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertTrue("Fehler: Element 396 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(396)); + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); + dieListe.einfuegenBei(18, 572); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733}); + + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733, 709}); + + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733, 709, 932}); + + dieListe.einfuegenBei(16, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{168, 570, 269, 744, 882, 275, 427, 793, 957, 802, 174, 529, 969, 21, 435, 209, 26, 625, 56, 572, 634, 19, 646, 434, 768, 653, 274, 596, 834, 125, 396, 32, 793, 514, 413, 652, 758, 758, 948, 85, 638, 842, 577, 139, 521, 605, 841, 620, 829, 584, 967, 991, 50, 705, 670, 787, 686, 795, 733, 709, 932}); + + assertFalse("Fehler: Element 911 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(911)); + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{482}); + + dieListe.einfuegenBei(0, 248); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 482}); + + dieListe.einfuegenBei(1, 151); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 151, 482}); + + assertTrue("Fehler: Element 482 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(482)); + dieListe.einfuegenBei(1, 526); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 526, 151, 482}); + + dieListe.einfuegenBei(1, 669); + Tester.pruefeListenInhalt(dieListe, new int[]{248, 669, 526, 151, 482}); + + dieListe.einfuegenBei(0, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 151, 482}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + assertFalse("Fehler: Element 253 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(253)); + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.einfuegenBei(4, 528); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 528, 151, 482}); + + dieListe.einfuegenBei(7, 694); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 528, 151, 482, 694}); + + dieListe.einfuegenBei(4, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 528, 151, 482, 694}); + + dieListe.einfuegenBei(5, 181); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 694}); + + dieListe.anhaengen(825); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 694, 825}); + + dieListe.einfuegenBei(11, 388); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 694, 825, 388}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + assertFalse("Fehler: Element 584 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(584)); + dieListe.einfuegenBei(9, 79); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 79, 694, 825, 388}); + + assertFalse("Fehler: Element 41 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(41)); + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 79, 694, 825, 388, 152}); + + dieListe.einfuegenBei(11, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152}); + + dieListe.einfuegenBei(5, 350); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152}); + + dieListe.einfuegenBei(4, 975); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152}); + + assertFalse("Fehler: Element 963 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(963)); + dieListe.anhaengen(625); + Tester.pruefeListenInhalt(dieListe, new int[]{553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625}); + + assertTrue("Fehler: Element 350 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(350)); + dieListe.einfuegenBei(0, 38); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625}); + + dieListe.anhaengen(548); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625, 548}); + + dieListe.einfuegenBei(3, 24); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 825, 388, 152, 625, 548}); + + assertFalse("Fehler: Element 626 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(626)); + assertFalse("Fehler: Element 929 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(929)); + dieListe.einfuegenBei(16, 605); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 79, 694, 360, 605, 825, 388, 152, 625, 548}); + + dieListe.einfuegenBei(13, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 605, 825, 388, 152, 625, 548}); + + dieListe.einfuegenBei(17, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 625, 548}); + + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 625, 548, 868}); + + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 625, 548, 868, 797}); + + dieListe.einfuegenBei(22, 155); + Tester.pruefeListenInhalt(dieListe, new int[]{38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797}); + + dieListe.einfuegenBei(0, 50); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797}); + + dieListe.einfuegenBei(3, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797}); + + assertTrue("Fehler: Element 528 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(528)); + assertFalse("Fehler: Element 839 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(839)); + dieListe.anhaengen(128); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128}); + + dieListe.anhaengen(185); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185}); + + assertTrue("Fehler: Element 975 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(975)); + dieListe.einfuegenBei(1, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185, 118}); + + dieListe.einfuegenBei(1, 612); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185, 118}); + + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 155, 625, 548, 868, 797, 128, 185, 118, 436}); + + dieListe.einfuegenBei(26, 402); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437}); + + dieListe.anhaengen(462); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462}); + + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.anhaengen(274); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462, 274}); + + dieListe.anhaengen(722); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462, 274, 722}); + + dieListe.anhaengen(875); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 462, 274, 722, 875}); + + assertFalse("Fehler: Element 757 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(757)); + assertFalse("Fehler: Element 326 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(326)); + dieListe.einfuegenBei(37, 66); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 66, 462, 274, 722, 875}); + + assertTrue("Fehler: Element 825 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(825)); + dieListe.einfuegenBei(37, 200); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875}); + + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + assertFalse("Fehler: Element 817 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(817)); + dieListe.anhaengen(903); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 903}); + + dieListe.einfuegenBei(33, 590); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 903}); + + assertTrue("Fehler: Element 436 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(436)); + assertFalse("Fehler: Element 208 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(208)); + dieListe.einfuegenBei(44, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + dieListe.einfuegenBei(6, 228); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166}); + + dieListe.einfuegenBei(32, 852); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166}); + + assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985)); + assertTrue("Fehler: Element 548 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(548)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340}); + + dieListe.anhaengen(287); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.einfuegenBei(36, 817); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.einfuegenBei(8, 715); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 228, 248, 715, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.einfuegenBei(6, 275); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287}); + + dieListe.anhaengen(354); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354}); + + dieListe.einfuegenBei(11, 210); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354}); + + dieListe.einfuegenBei(25, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354}); + + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + dieListe.einfuegenBei(57, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750}); + + dieListe.einfuegenBei(13, 706); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750}); + + assertTrue("Fehler: Element 526 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(526)); + dieListe.einfuegenBei(42, 338); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750}); + + assertFalse("Fehler: Element 0 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(0)); + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900}); + + assertTrue("Fehler: Element 903 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(903)); + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + dieListe.einfuegenBei(23, 730); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900}); + + assertTrue("Fehler: Element 210 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(210)); + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900, 637}); + + dieListe.anhaengen(964); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900, 637, 964}); + + dieListe.einfuegenBei(23, 697); + Tester.pruefeListenInhalt(dieListe, new int[]{50, 612, 247, 38, 553, 92, 275, 228, 248, 715, 24, 210, 669, 706, 526, 975, 651, 350, 181, 528, 151, 482, 447, 697, 730, 79, 694, 360, 234, 75, 605, 825, 388, 152, 402, 155, 625, 548, 868, 852, 797, 128, 590, 817, 338, 185, 118, 436, 437, 200, 66, 462, 274, 722, 875, 36, 903, 166, 340, 287, 354, 435, 750, 900, 637, 964}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{126}); + + dieListe.anhaengen(503); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 503}); + + assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503)); + dieListe.einfuegenBei(1, 997); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 997, 503}); + + dieListe.einfuegenBei(0, 376); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 503}); + + assertFalse("Fehler: Element 766 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(766)); + assertFalse("Fehler: Element 10 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(10)); + dieListe.anhaengen(687); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 503, 687}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + dieListe.einfuegenBei(3, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 613, 503, 687}); + + assertFalse("Fehler: Element 820 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(820)); + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 613, 503, 687, 118}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 997, 613, 503, 687, 118, 869}); + + dieListe.einfuegenBei(2, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 281, 997, 613, 503, 687, 118, 869}); + + assertFalse("Fehler: Element 945 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(945)); + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 281, 997, 613, 503, 687, 118, 869, 388}); + + dieListe.einfuegenBei(2, 323); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 323, 281, 997, 613, 503, 687, 118, 869, 388}); + + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + dieListe.einfuegenBei(2, 125); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388}); + + assertFalse("Fehler: Element 591 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(591)); + dieListe.anhaengen(296); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388, 296}); + + assertTrue("Fehler: Element 281 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(281)); + dieListe.einfuegenBei(1, 590); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388, 296}); + + assertTrue("Fehler: Element 281 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(281)); + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 997, 613, 503, 687, 118, 869, 388, 296, 490}); + + dieListe.einfuegenBei(6, 941); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 997, 613, 503, 687, 118, 869, 388, 296, 490}); + + dieListe.einfuegenBei(7, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 997, 613, 503, 687, 118, 869, 388, 296, 490}); + + dieListe.einfuegenBei(14, 491); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 997, 613, 503, 687, 118, 869, 491, 388, 296, 490}); + + dieListe.einfuegenBei(8, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 687, 118, 869, 491, 388, 296, 490}); + + dieListe.anhaengen(630); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 687, 118, 869, 491, 388, 296, 490, 630}); + + dieListe.einfuegenBei(12, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 869, 491, 388, 296, 490, 630}); + + dieListe.einfuegenBei(15, 341); + Tester.pruefeListenInhalt(dieListe, new int[]{376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630}); + + assertTrue("Fehler: Element 416 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(416)); + dieListe.einfuegenBei(0, 628); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 416, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + dieListe.einfuegenBei(10, 966); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 416, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + dieListe.einfuegenBei(9, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 416, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95)); + dieListe.einfuegenBei(11, 81); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503)); + dieListe.einfuegenBei(10, 81); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 490, 630, 470, 137}); + + assertTrue("Fehler: Element 137 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(137)); + assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778)); + dieListe.einfuegenBei(25, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 137}); + + assertFalse("Fehler: Element 910 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(910)); + assertTrue("Fehler: Element 126 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(126)); + assertTrue("Fehler: Element 323 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(323)); + dieListe.einfuegenBei(18, 711); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 137}); + + dieListe.anhaengen(307); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 137, 307}); + + dieListe.einfuegenBei(30, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307}); + + assertTrue("Fehler: Element 997 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(997)); + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914}); + + assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118)); + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914, 189}); + + dieListe.einfuegenBei(10, 719); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914, 189}); + + assertTrue("Fehler: Element 997 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(997)); + dieListe.einfuegenBei(13, 63); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 914, 189}); + + dieListe.einfuegenBei(35, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189}); + + assertTrue("Fehler: Element 380 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(380)); + dieListe.anhaengen(851); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851}); + + assertFalse("Fehler: Element 508 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(508)); + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100}); + + assertTrue("Fehler: Element 941 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(941)); + assertTrue("Fehler: Element 491 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(491)); + dieListe.einfuegenBei(14, 274); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100}); + + assertTrue("Fehler: Element 687 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(687)); + assertTrue("Fehler: Element 590 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(590)); + dieListe.einfuegenBei(30, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100}); + + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100, 213}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); + assertTrue("Fehler: Element 941 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(941)); + dieListe.anhaengen(401); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100, 213, 401}); + + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 914, 189, 851, 100, 213, 401, 870}); + + dieListe.einfuegenBei(38, 201); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870}); + + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651}); + + dieListe.anhaengen(508); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372}); + + assertTrue("Fehler: Element 63 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(63)); + dieListe.anhaengen(805); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805}); + + dieListe.einfuegenBei(31, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805}); + + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170}); + + assertFalse("Fehler: Element 263 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(263)); + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496}); + + dieListe.einfuegenBei(34, 331); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496}); + + dieListe.einfuegenBei(38, 318); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496}); + + assertFalse("Fehler: Element 102 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(102)); + dieListe.anhaengen(212); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496, 212}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496, 212, 626}); + + assertFalse("Fehler: Element 927 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(927)); + dieListe.einfuegenBei(34, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 666, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 170, 490, 496, 212, 626}); + + assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367)); + dieListe.einfuegenBei(54, 123); + Tester.pruefeListenInhalt(dieListe, new int[]{628, 376, 590, 126, 125, 323, 281, 941, 380, 778, 719, 81, 416, 63, 274, 81, 966, 997, 613, 503, 368, 711, 687, 118, 341, 869, 491, 388, 296, 77, 91, 26, 490, 630, 666, 331, 470, 362, 137, 318, 307, 390, 201, 914, 189, 851, 100, 213, 401, 870, 651, 508, 372, 805, 123, 170, 490, 496, 212, 626}); + + assertTrue("Fehler: Element 613 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(613)); + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{766}); + + dieListe.einfuegenBei(1, 357); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 357}); + + assertFalse("Fehler: Element 702 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(702)); + dieListe.einfuegenBei(1, 250); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 250, 357}); + + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 250, 357, 965}); + + dieListe.anhaengen(151); + Tester.pruefeListenInhalt(dieListe, new int[]{766, 250, 357, 965, 151}); + + dieListe.einfuegenBei(0, 918); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151}); + + dieListe.anhaengen(175); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151, 175}); + + assertTrue("Fehler: Element 250 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(250)); + dieListe.anhaengen(545); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151, 175, 545}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 357, 965, 151, 175, 545, 894}); + + dieListe.einfuegenBei(3, 20); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 20, 357, 965, 151, 175, 545, 894}); + + dieListe.einfuegenBei(4, 365); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 20, 365, 357, 965, 151, 175, 545, 894}); + + dieListe.einfuegenBei(4, 101); + Tester.pruefeListenInhalt(dieListe, new int[]{918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894}); + + assertTrue("Fehler: Element 766 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(766)); + dieListe.einfuegenBei(0, 430); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894}); + + dieListe.anhaengen(655); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894, 655}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 894, 655, 105}); + + assertTrue("Fehler: Element 766 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(766)); + dieListe.einfuegenBei(12, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 798, 894, 655, 105}); + + assertTrue("Fehler: Element 101 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(101)); + dieListe.einfuegenBei(12, 317); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 894, 655, 105}); + + dieListe.einfuegenBei(14, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105}); + + assertTrue("Fehler: Element 175 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(175)); + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + dieListe.anhaengen(103); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51}); + + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + dieListe.anhaengen(806); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806}); + + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96}); + + assertTrue("Fehler: Element 655 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(655)); + assertFalse("Fehler: Element 60 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(60)); + dieListe.anhaengen(52); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52}); + + dieListe.einfuegenBei(6, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52}); + + assertTrue("Fehler: Element 365 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(365)); + dieListe.einfuegenBei(10, 457); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52}); + + dieListe.anhaengen(991); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570}); + + dieListe.anhaengen(810); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570, 810}); + + dieListe.anhaengen(761); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570, 810, 761}); + + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 991, 570, 810, 761, 618}); + + assertFalse("Fehler: Element 989 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(989)); + dieListe.einfuegenBei(26, 315); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618}); + + dieListe.einfuegenBei(3, 309); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618}); + + assertTrue("Fehler: Element 545 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(545)); + assertTrue("Fehler: Element 20 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(20)); + assertTrue("Fehler: Element 894 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(894)); + dieListe.anhaengen(597); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597}); + + assertFalse("Fehler: Element 328 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(328)); + assertTrue("Fehler: Element 52 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(52)); + assertFalse("Fehler: Element 294 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(294)); + dieListe.anhaengen(283); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283}); + + dieListe.anhaengen(809); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809}); + + assertTrue("Fehler: Element 283 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(283)); + dieListe.anhaengen(487); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487}); + + dieListe.einfuegenBei(7, 951); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487}); + + assertTrue("Fehler: Element 545 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(545)); + assertFalse("Fehler: Element 816 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(816)); + dieListe.anhaengen(78); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78}); + + dieListe.einfuegenBei(6, 10); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47}); + + dieListe.anhaengen(62); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62}); + + assertTrue("Fehler: Element 357 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(357)); + assertTrue("Fehler: Element 78 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(78)); + dieListe.anhaengen(508); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508}); + + dieListe.einfuegenBei(10, 913); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508}); + + dieListe.einfuegenBei(5, 415); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508}); + + dieListe.anhaengen(199); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199}); + + dieListe.einfuegenBei(35, 505); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199}); + + dieListe.anhaengen(98); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199, 98}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + assertTrue("Fehler: Element 52 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(52)); + dieListe.einfuegenBei(29, 759); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199, 98}); + + dieListe.einfuegenBei(48, 366); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 47, 62, 508, 199, 366, 98}); + + dieListe.einfuegenBei(44, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98}); + + dieListe.einfuegenBei(39, 63); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98}); + + assertTrue("Fehler: Element 798 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(798)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391}); + + assertFalse("Fehler: Element 204 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(204)); + assertFalse("Fehler: Element 738 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(738)); + assertTrue("Fehler: Element 913 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(913)); + dieListe.einfuegenBei(17, 613); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450}); + + assertFalse("Fehler: Element 115 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(115)); + assertTrue("Fehler: Element 759 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(759)); + assertTrue("Fehler: Element 457 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(457)); + dieListe.anhaengen(39); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39}); + + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + assertTrue("Fehler: Element 51 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(51)); + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305}); + + dieListe.anhaengen(650); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650}); + + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + assertTrue("Fehler: Element 415 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(415)); + assertFalse("Fehler: Element 145 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(145)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650, 191}); + + dieListe.anhaengen(761); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650, 191, 761}); + + assertTrue("Fehler: Element 761 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(761)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{430, 918, 766, 309, 250, 415, 20, 10, 101, 951, 436, 913, 365, 357, 965, 457, 151, 613, 175, 545, 317, 798, 16, 894, 655, 105, 103, 99, 51, 806, 759, 96, 52, 315, 991, 570, 810, 505, 761, 618, 63, 597, 283, 809, 487, 78, 105, 47, 62, 508, 199, 366, 98, 391, 450, 39, 305, 650, 191, 761, 45}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 901); + Tester.pruefeListenInhalt(dieListe, new int[]{901}); + + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{901, 308}); + + dieListe.einfuegenBei(1, 511); + Tester.pruefeListenInhalt(dieListe, new int[]{901, 511, 308}); + + assertFalse("Fehler: Element 954 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(954)); + dieListe.einfuegenBei(0, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 901, 511, 308}); + + dieListe.einfuegenBei(2, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 901, 758, 511, 308}); + + dieListe.einfuegenBei(1, 787); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 901, 758, 511, 308}); + + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + assertFalse("Fehler: Element 853 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(853)); + dieListe.anhaengen(302); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 901, 758, 511, 308, 302}); + + dieListe.einfuegenBei(2, 137); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302}); + + assertTrue("Fehler: Element 137 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(137)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302, 688}); + + dieListe.anhaengen(946); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302, 688, 946}); + + dieListe.anhaengen(222); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 758, 511, 308, 302, 688, 946, 222}); + + dieListe.einfuegenBei(4, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + assertTrue("Fehler: Element 511 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(511)); + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341}); + + dieListe.anhaengen(188); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188}); + + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334}); + + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857}); + + assertFalse("Fehler: Element 970 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(970)); + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288}); + + dieListe.einfuegenBei(0, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288}); + + assertFalse("Fehler: Element 737 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(737)); + dieListe.einfuegenBei(19, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220}); + + dieListe.einfuegenBei(1, 853); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220}); + + dieListe.anhaengen(814); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814}); + + dieListe.einfuegenBei(7, 305); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814}); + + dieListe.anhaengen(767); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814, 767}); + + dieListe.einfuegenBei(9, 229); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 334, 857, 288, 220, 814, 767}); + + dieListe.einfuegenBei(19, 35); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767}); + + dieListe.anhaengen(512); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676}); + + assertFalse("Fehler: Element 916 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(916)); + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466}); + + dieListe.einfuegenBei(13, 101); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466}); + + assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302)); + dieListe.einfuegenBei(16, 381); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466}); + + dieListe.einfuegenBei(31, 434); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496}); + + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846}); + + dieListe.anhaengen(66); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 66}); + + assertTrue("Fehler: Element 857 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(857)); + assertTrue("Fehler: Element 633 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(633)); + dieListe.einfuegenBei(34, 945); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66}); + + dieListe.anhaengen(156); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156}); + + dieListe.anhaengen(536); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + dieListe.einfuegenBei(24, 65); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + assertFalse("Fehler: Element 922 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(922)); + dieListe.einfuegenBei(3, 39); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + dieListe.einfuegenBei(5, 853); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + assertTrue("Fehler: Element 220 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(220)); + dieListe.einfuegenBei(22, 657); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 657, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852}); + + assertTrue("Fehler: Element 302 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(302)); + dieListe.anhaengen(821); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 657, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(22, 446); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 446, 657, 188, 35, 334, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + assertFalse("Fehler: Element 463 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(463)); + assertFalse("Fehler: Element 807 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(807)); + dieListe.einfuegenBei(27, 630); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 308, 302, 101, 688, 946, 381, 222, 168, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(13, 557); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(22, 740); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(1, 926); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(6, 524); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.einfuegenBei(14, 943); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821}); + + dieListe.anhaengen(459); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459}); + + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799}); + + dieListe.einfuegenBei(17, 315); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 315, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799}); + + dieListe.anhaengen(469); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 315, 308, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799, 469}); + + assertTrue("Fehler: Element 853 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(853)); + assertFalse("Fehler: Element 728 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(728)); + dieListe.einfuegenBei(19, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799, 469}); + + dieListe.einfuegenBei(17, 37); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 799, 469}); + + dieListe.einfuegenBei(55, 474); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469}); + + assertFalse("Fehler: Element 947 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(947)); + assertTrue("Fehler: Element 688 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(688)); + dieListe.anhaengen(999); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999}); + + dieListe.einfuegenBei(29, 549); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999}); + + dieListe.einfuegenBei(60, 556); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556}); + + assertTrue("Fehler: Element 536 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(536)); + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77}); + + dieListe.einfuegenBei(7, 760); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470}); + + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97}); + + dieListe.einfuegenBei(52, 387); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97}); + + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102}); + + assertFalse("Fehler: Element 958 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(958)); + dieListe.einfuegenBei(55, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102}); + + dieListe.einfuegenBei(37, 76); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 76, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102}); + + dieListe.anhaengen(289); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 76, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102, 289}); + + assertTrue("Fehler: Element 37 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(37)); + assertTrue("Fehler: Element 229 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(229)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{42, 926, 853, 633, 39, 787, 524, 760, 853, 137, 901, 688, 305, 758, 229, 943, 511, 557, 37, 315, 308, 36, 302, 101, 688, 946, 381, 222, 168, 740, 549, 341, 446, 657, 188, 35, 334, 76, 630, 857, 65, 288, 220, 814, 767, 512, 676, 466, 434, 496, 846, 945, 66, 387, 156, 536, 532, 852, 821, 459, 474, 799, 469, 999, 556, 77, 470, 97, 102, 289, 395}); + + assertFalse("Fehler: Element 586 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(586)); + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + assertFalse("Fehler: Element 310 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(310)); + assertTrue("Fehler: Element 799 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(799)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest6.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest6.java new file mode 100644 index 0000000..7ce4637 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest6.java @@ -0,0 +1,2762 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest6. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest6 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{651}); + + dieListe.einfuegenBei(1, 576); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 576}); + + assertTrue("Fehler: Element 576 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(576)); + assertTrue("Fehler: Element 651 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(651)); + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 576, 763}); + + assertFalse("Fehler: Element 586 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(586)); + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 576, 763, 920}); + + dieListe.einfuegenBei(0, 418); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 651, 576, 763, 920}); + + dieListe.anhaengen(781); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 651, 576, 763, 920, 781}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 576, 763, 920, 781}); + + dieListe.anhaengen(304); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 576, 763, 920, 781, 304}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 920, 781, 304}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + assertFalse("Fehler: Element 468 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(468)); + assertTrue("Fehler: Element 781 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(781)); + dieListe.einfuegenBei(0, 223); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 304}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.anhaengen(939); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 304, 939}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 781, 939}); + + dieListe.einfuegenBei(4, 685); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939}); + + dieListe.anhaengen(475); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939, 475}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939}); + + assertTrue("Fehler: Element 418 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(418)); + dieListe.einfuegenBei(7, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{223, 418, 763, 920, 685, 781, 939, 598}); + + assertFalse("Fehler: Element 843 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(843)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 920, 685, 781, 939, 598}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 685, 781, 939, 598}); + + dieListe.anhaengen(402); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 763, 685, 781, 939, 598, 402}); + + dieListe.einfuegenBei(1, 36); + Tester.pruefeListenInhalt(dieListe, new int[]{418, 36, 763, 685, 781, 939, 598, 402}); + + dieListe.einfuegenBei(0, 13); + Tester.pruefeListenInhalt(dieListe, new int[]{13, 418, 36, 763, 685, 781, 939, 598, 402}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{862}); + + dieListe.einfuegenBei(0, 814); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 862}); + + assertTrue("Fehler: Element 862 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(862)); + dieListe.einfuegenBei(0, 615); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 814, 862}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862}); + + dieListe.einfuegenBei(2, 963); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963}); + + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963, 419}); + + assertTrue("Fehler: Element 862 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(862)); + dieListe.einfuegenBei(4, 371); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 862, 963, 419, 371}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 419, 371}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371}); + + assertFalse("Fehler: Element 609 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(609)); + dieListe.anhaengen(641); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371, 641}); + + assertTrue("Fehler: Element 615 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(615)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 963, 371}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371}); + + assertTrue("Fehler: Element 615 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(615)); + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952}); + + assertFalse("Fehler: Element 187 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(187)); + assertTrue("Fehler: Element 952 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(952)); + dieListe.anhaengen(133); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133}); + + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133, 958}); + + dieListe.anhaengen(20); + Tester.pruefeListenInhalt(dieListe, new int[]{615, 371, 952, 133, 958, 20}); + + assertFalse("Fehler: Element 422 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(422)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{371, 952, 133, 958, 20}); + + assertTrue("Fehler: Element 958 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(958)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(772); + Tester.pruefeListenInhalt(dieListe, new int[]{772}); + + assertFalse("Fehler: Element 224 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(224)); + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{772, 968}); + + dieListe.einfuegenBei(1, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{772, 105, 968}); + + dieListe.einfuegenBei(0, 503); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 968}); + + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + assertFalse("Fehler: Element 803 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(803)); + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + dieListe.anhaengen(74); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 968, 74}); + + dieListe.einfuegenBei(3, 682); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 772, 105, 682, 968, 74}); + + assertTrue("Fehler: Element 772 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(772)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74}); + + assertTrue("Fehler: Element 105 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(105)); + dieListe.einfuegenBei(2, 614); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 614, 682, 968, 74}); + + dieListe.einfuegenBei(0, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74}); + + assertTrue("Fehler: Element 503 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(503)); + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + dieListe.anhaengen(878); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74, 878}); + + dieListe.einfuegenBei(8, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 614, 682, 968, 74, 878, 185}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{525, 503, 105, 682, 968, 74, 878, 185}); + + assertTrue("Fehler: Element 878 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(878)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74, 878, 185}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 682, 968, 74, 185}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 74, 185}); + + assertFalse("Fehler: Element 313 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(313)); + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 74, 185, 97}); + + dieListe.einfuegenBei(3, 177); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 185, 97}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 97}); + + dieListe.anhaengen(816); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 97, 816}); + + assertTrue("Fehler: Element 105 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(105)); + dieListe.einfuegenBei(5, 180); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 180, 97, 816}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 74, 180, 816}); + + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.einfuegenBei(4, 40); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816}); + + assertFalse("Fehler: Element 849 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(849)); + dieListe.anhaengen(910); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816, 910}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 40, 74, 180, 816, 910, 679}); + + assertFalse("Fehler: Element 295 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(295)); + dieListe.einfuegenBei(4, 739); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 739, 40, 74, 180, 816, 910, 679}); + + dieListe.anhaengen(773); + Tester.pruefeListenInhalt(dieListe, new int[]{503, 105, 968, 177, 739, 40, 74, 180, 816, 910, 679, 773}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 810); + Tester.pruefeListenInhalt(dieListe, new int[]{810}); + + dieListe.einfuegenBei(0, 594); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 810}); + + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 810, 914}); + + assertTrue("Fehler: Element 810 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(810)); + assertFalse("Fehler: Element 84 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(84)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914}); + + dieListe.einfuegenBei(2, 791); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791}); + + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154}); + + dieListe.anhaengen(79); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79}); + + dieListe.anhaengen(266); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266}); + + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266, 535}); + + dieListe.einfuegenBei(6, 522); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 522, 266, 535}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 791, 92, 154, 79, 266, 535}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 535}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 535, 496}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496}); + + dieListe.anhaengen(192); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192}); + + dieListe.anhaengen(723); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192, 723}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 92, 154, 79, 266, 496, 192, 723, 299}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 496, 192, 723, 299}); + + assertTrue("Fehler: Element 299 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(299)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 496, 192, 299}); + + assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407)); + dieListe.einfuegenBei(5, 143); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 143, 496, 192, 299}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 266, 143, 496, 192}); + + dieListe.einfuegenBei(4, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 126, 266, 143, 496, 192}); + + dieListe.einfuegenBei(7, 374); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 154, 79, 126, 266, 143, 374, 496, 192}); + + dieListe.einfuegenBei(2, 47); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 154, 79, 126, 266, 143, 374, 496, 192}); + + dieListe.einfuegenBei(8, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.einfuegenBei(3, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.einfuegenBei(3, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 47, 599, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + assertTrue("Fehler: Element 686 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(686)); + dieListe.einfuegenBei(3, 216); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 79, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 266, 143, 686, 374, 496, 192}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 266, 143, 374, 496, 192}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 374, 496, 192}); + + dieListe.einfuegenBei(10, 865); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 374, 496, 865, 192}); + + assertTrue("Fehler: Element 607 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(607)); + assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914)); + dieListe.einfuegenBei(8, 444); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192, 137}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 192, 137, 349}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349}); + + assertTrue("Fehler: Element 914 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(914)); + assertFalse("Fehler: Element 156 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(156)); + assertTrue("Fehler: Element 349 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(349)); + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318}); + + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{810, 914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318, 700}); + + assertTrue("Fehler: Element 444 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(444)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 154, 126, 143, 444, 374, 496, 865, 137, 349, 318, 700}); + + assertTrue("Fehler: Element 216 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(216)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 154, 126, 143, 444, 496, 865, 137, 349, 318, 700}); + + assertFalse("Fehler: Element 597 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(597)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 126, 143, 444, 496, 865, 137, 349, 318, 700}); + + dieListe.einfuegenBei(10, 414); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 126, 143, 444, 496, 865, 137, 414, 349, 318, 700}); + + assertFalse("Fehler: Element 188 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(188)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 414, 349, 318, 700}); + + assertFalse("Fehler: Element 175 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(175)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 414, 349, 700}); + + dieListe.einfuegenBei(9, 515); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 865, 137, 515, 414, 349, 700}); + + dieListe.einfuegenBei(7, 768); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 768, 865, 137, 515, 414, 349, 700}); + + dieListe.einfuegenBei(7, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 82, 768, 865, 137, 515, 414, 349, 700}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 82, 768, 865, 515, 414, 349, 700}); + + dieListe.einfuegenBei(4, 443); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 82, 768, 865, 515, 414, 349, 700}); + + dieListe.einfuegenBei(8, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700}); + + dieListe.einfuegenBei(3, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700}); + + assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553)); + dieListe.anhaengen(503); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700, 503}); + + dieListe.anhaengen(665); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 414, 349, 700, 503, 665}); + + dieListe.einfuegenBei(14, 923); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 700, 503, 665}); + + assertFalse("Fehler: Element 274 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(274)); + assertTrue("Fehler: Element 713 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(713)); + assertFalse("Fehler: Element 138 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(138)); + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 700, 503, 665, 518}); + + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 311, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 414, 349, 503, 665, 518, 758}); + + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 758}); + + assertFalse("Fehler: Element 662 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(662)); + dieListe.anhaengen(578); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 758, 578}); + + dieListe.einfuegenBei(18, 349); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578}); + + dieListe.einfuegenBei(11, 961); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 443, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 713, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166}); + + assertFalse("Fehler: Element 776 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(776)); + dieListe.einfuegenBei(8, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{914, 599, 216, 607, 143, 444, 496, 713, 665, 82, 768, 961, 865, 515, 923, 349, 503, 665, 518, 349, 758, 578, 166}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{588}); + + assertFalse("Fehler: Element 942 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(942)); + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{264}); + + dieListe.einfuegenBei(1, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{264, 842}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{709}); + + assertTrue("Fehler: Element 709 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(709)); + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 962); + Tester.pruefeListenInhalt(dieListe, new int[]{962}); + + dieListe.einfuegenBei(0, 257); + Tester.pruefeListenInhalt(dieListe, new int[]{257, 962}); + + dieListe.einfuegenBei(0, 662); + Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 962}); + + dieListe.einfuegenBei(2, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 798, 962}); + + assertFalse("Fehler: Element 327 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(327)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{662, 257, 798}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + + assertTrue("Fehler: Element 70 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(70)); + assertTrue("Fehler: Element 70 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(70)); + assertFalse("Fehler: Element 181 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(181)); + assertFalse("Fehler: Element 741 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(741)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{890}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{465}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{465, 118}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{118}); + + dieListe.einfuegenBei(1, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665}); + + assertTrue("Fehler: Element 665 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(665)); + dieListe.einfuegenBei(2, 90); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 90}); + + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 90, 998}); + + dieListe.anhaengen(60); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 90, 998, 60}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60}); + + dieListe.anhaengen(365); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60, 365}); + + dieListe.einfuegenBei(1, 45); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 45, 665, 998, 60, 365}); + + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 45, 665, 998, 60, 365, 275}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 665, 998, 60, 365, 275}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(69); + Tester.pruefeListenInhalt(dieListe, new int[]{69}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(612); + Tester.pruefeListenInhalt(dieListe, new int[]{612}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{417}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{595}); + + dieListe.einfuegenBei(0, 939); + Tester.pruefeListenInhalt(dieListe, new int[]{939, 595}); + + assertTrue("Fehler: Element 939 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(939)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 141); + Tester.pruefeListenInhalt(dieListe, new int[]{141}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{141, 570}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{570}); + + assertFalse("Fehler: Element 263 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(263)); + assertFalse("Fehler: Element 448 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(448)); + assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95)); + dieListe.einfuegenBei(1, 684); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 684}); + + dieListe.anhaengen(264); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 684, 264}); + + dieListe.einfuegenBei(1, 478); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 478, 684, 264}); + + dieListe.einfuegenBei(1, 300); + Tester.pruefeListenInhalt(dieListe, new int[]{570, 300, 478, 684, 264}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{300, 478, 684, 264}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + assertTrue("Fehler: Element 684 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(684)); + assertTrue("Fehler: Element 478 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(478)); + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{300, 478, 684, 264, 308}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 264, 308}); + + assertTrue("Fehler: Element 684 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(684)); + dieListe.einfuegenBei(4, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 264, 308, 743}); + + assertFalse("Fehler: Element 825 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(825)); + dieListe.einfuegenBei(2, 721); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 721, 264, 308, 743}); + + dieListe.einfuegenBei(2, 688); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 721, 264, 308, 743}); + + dieListe.einfuegenBei(4, 214); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 721, 214, 264, 308, 743}); + + dieListe.einfuegenBei(3, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 214, 264, 308, 743}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 743}); + + dieListe.einfuegenBei(7, 845); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743}); + + dieListe.anhaengen(371); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743, 371}); + + dieListe.anhaengen(606); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 743, 371, 606}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 371, 606}); + + assertFalse("Fehler: Element 196 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(196)); + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 606}); + + assertTrue("Fehler: Element 721 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(721)); + dieListe.anhaengen(817); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 845, 606, 817}); + + dieListe.einfuegenBei(7, 575); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 606, 817}); + + assertFalse("Fehler: Element 364 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(364)); + assertTrue("Fehler: Element 845 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(845)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 606}); + + dieListe.einfuegenBei(9, 704); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 704, 606}); + + dieListe.einfuegenBei(9, 587); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 684, 688, 144, 721, 264, 308, 575, 845, 587, 704, 606}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 721, 264, 308, 575, 845, 587, 704, 606}); + + assertFalse("Fehler: Element 910 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(910)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 264, 308, 575, 845, 587, 704, 606}); + + dieListe.einfuegenBei(10, 871); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871}); + + assertTrue("Fehler: Element 704 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(704)); + dieListe.einfuegenBei(1, 600); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 600, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871}); + + dieListe.einfuegenBei(1, 910); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 600, 688, 144, 264, 308, 575, 845, 587, 704, 606, 871}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 600, 688, 144, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.einfuegenBei(2, 326); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 600, 688, 144, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 144, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871}); + + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871, 866}); + + dieListe.anhaengen(406); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 871, 866, 406}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406}); + + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954}); + + dieListe.einfuegenBei(2, 916); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954}); + + dieListe.anhaengen(483); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 308, 575, 587, 704, 606, 866, 406, 954, 483}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483}); + + assertFalse("Fehler: Element 477 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(477)); + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483, 280}); + + assertFalse("Fehler: Element 307 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(307)); + dieListe.anhaengen(424); + Tester.pruefeListenInhalt(dieListe, new int[]{478, 910, 916, 326, 688, 264, 575, 587, 704, 606, 866, 406, 954, 483, 280, 424}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 931); + Tester.pruefeListenInhalt(dieListe, new int[]{931}); + + assertFalse("Fehler: Element 999 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(999)); + dieListe.anhaengen(829); + Tester.pruefeListenInhalt(dieListe, new int[]{931, 829}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{829}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 737); + Tester.pruefeListenInhalt(dieListe, new int[]{737}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 412); + Tester.pruefeListenInhalt(dieListe, new int[]{412}); + + dieListe.anhaengen(455); + Tester.pruefeListenInhalt(dieListe, new int[]{412, 455}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{412}); + + dieListe.einfuegenBei(1, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{412, 884}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{884}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 995); + Tester.pruefeListenInhalt(dieListe, new int[]{995}); + + dieListe.einfuegenBei(1, 304); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304}); + + dieListe.anhaengen(220); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 220}); + + dieListe.anhaengen(348); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 220, 348}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{995, 304, 348}); + + assertFalse("Fehler: Element 706 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(706)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 348}); + + dieListe.anhaengen(944); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 348, 944}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944}); + + dieListe.einfuegenBei(1, 372); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 372, 944}); + + assertTrue("Fehler: Element 944 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(944)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225}); + + dieListe.einfuegenBei(1, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225}); + + assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225)); + dieListe.anhaengen(693); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 693}); + + dieListe.einfuegenBei(4, 543); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 543, 693}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 496, 944, 225, 543, 693, 718}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225, 543, 693, 718}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 944, 225, 543, 693, 718, 896}); + + assertTrue("Fehler: Element 225 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(225)); + dieListe.einfuegenBei(0, 159); + Tester.pruefeListenInhalt(dieListe, new int[]{159, 304, 944, 225, 543, 693, 718, 896}); + + dieListe.einfuegenBei(4, 199); + Tester.pruefeListenInhalt(dieListe, new int[]{159, 304, 944, 225, 199, 543, 693, 718, 896}); + + assertTrue("Fehler: Element 304 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(304)); + assertTrue("Fehler: Element 896 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(896)); + dieListe.einfuegenBei(0, 317); + Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896}); + + dieListe.anhaengen(858); + Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858}); + + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858, 581}); + + dieListe.einfuegenBei(0, 97); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 944, 225, 199, 543, 693, 718, 896, 858, 581}); + + dieListe.einfuegenBei(4, 667); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 858, 581}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 581}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 199, 543, 693, 718, 896, 581, 267}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267}); + + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267, 368}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 718, 896, 581, 267, 368, 245}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245}); + + dieListe.anhaengen(371); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245, 371}); + + assertFalse("Fehler: Element 828 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(828)); + dieListe.einfuegenBei(2, 919); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 245, 371}); + + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371}); + + dieListe.einfuegenBei(3, 272); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718}); + + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568}); + + assertFalse("Fehler: Element 287 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(287)); + dieListe.einfuegenBei(3, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 874, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 896, 581, 267, 368, 371, 718, 568}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568}); + + dieListe.anhaengen(810); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810}); + + assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267)); + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65}); + + dieListe.anhaengen(234); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65, 234}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 810, 65, 234, 285}); + + dieListe.einfuegenBei(17, 501); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + dieListe.einfuegenBei(7, 818); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 919, 272, 159, 304, 667, 818, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 225, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285}); + + assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718)); + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277}); + + dieListe.anhaengen(319); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319}); + + dieListe.anhaengen(190); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + dieListe.einfuegenBei(2, 631); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 631, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + dieListe.einfuegenBei(13, 516); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 631, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + assertTrue("Fehler: Element 371 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(371)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 285, 277, 319, 190}); + + dieListe.entferneBei(21); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446}); + + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922}); + + dieListe.anhaengen(442); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 304, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + assertTrue("Fehler: Element 818 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(818)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 371, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 718, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 317, 272, 159, 667, 818, 944, 543, 693, 581, 267, 516, 368, 568, 501, 810, 65, 234, 277, 319, 190, 446, 922, 442, 351}); + + assertTrue("Fehler: Element 234 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(234)); + assertTrue("Fehler: Element 922 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(922)); + assertTrue("Fehler: Element 351 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(351)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{157}); + + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 344}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{157}); + + assertTrue("Fehler: Element 157 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(157)); + assertTrue("Fehler: Element 157 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(157)); + assertTrue("Fehler: Element 157 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(157)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{897}); + + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{186}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{186, 758}); + + assertFalse("Fehler: Element 673 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(673)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{186}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(894); + Tester.pruefeListenInhalt(dieListe, new int[]{894}); + + dieListe.einfuegenBei(0, 873); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894}); + + dieListe.anhaengen(332); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 332}); + + assertTrue("Fehler: Element 873 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(873)); + assertFalse("Fehler: Element 519 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(519)); + dieListe.einfuegenBei(2, 79); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 79, 332}); + + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{873, 894, 79, 332, 482}); + + assertTrue("Fehler: Element 873 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(873)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{534}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{534, 923}); + + dieListe.einfuegenBei(0, 834); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 534, 923}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 923}); + + assertTrue("Fehler: Element 923 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(923)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 923, 45}); + + dieListe.anhaengen(275); + Tester.pruefeListenInhalt(dieListe, new int[]{834, 923, 45, 275}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 993); + Tester.pruefeListenInhalt(dieListe, new int[]{993}); + + dieListe.einfuegenBei(1, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 568}); + + dieListe.einfuegenBei(1, 966); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 966, 568}); + + dieListe.einfuegenBei(1, 131); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568}); + + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568, 863}); + + assertFalse("Fehler: Element 774 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(774)); + dieListe.anhaengen(123); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 966, 568, 863, 123}); + + dieListe.einfuegenBei(2, 480); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 966, 568, 863, 123}); + + assertFalse("Fehler: Element 873 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(873)); + assertFalse("Fehler: Element 528 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(528)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 568, 863, 123}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 123}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863}); + + dieListe.anhaengen(416); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416}); + + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416, 257}); + + dieListe.anhaengen(823); + Tester.pruefeListenInhalt(dieListe, new int[]{993, 131, 480, 863, 416, 257, 823}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(806); + Tester.pruefeListenInhalt(dieListe, new int[]{806}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(610); + Tester.pruefeListenInhalt(dieListe, new int[]{610}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{288}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 98); + Tester.pruefeListenInhalt(dieListe, new int[]{98}); + + dieListe.einfuegenBei(0, 255); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 98}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{255}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(742); + Tester.pruefeListenInhalt(dieListe, new int[]{742}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{742, 403}); + + dieListe.einfuegenBei(0, 236); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403}); + + assertTrue("Fehler: Element 236 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(236)); + dieListe.einfuegenBei(3, 278); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278}); + + assertTrue("Fehler: Element 278 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(278)); + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278, 21}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 278, 21, 154}); + + dieListe.einfuegenBei(3, 719); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 719, 278, 21, 154}); + + dieListe.einfuegenBei(7, 599); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 403, 719, 278, 21, 154, 599}); + + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 719, 278, 21, 154, 599}); + + dieListe.einfuegenBei(2, 605); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 742, 605, 719, 278, 21, 154, 599}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599}); + + dieListe.anhaengen(75); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75}); + + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528}); + + dieListe.anhaengen(138); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528, 138}); + + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 528, 138, 340}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340}); + + dieListe.anhaengen(744); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340, 744}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 278, 21, 154, 599, 75, 138, 340, 744, 719}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 340, 744, 719}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 340, 719}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 154, 599, 75, 138, 719}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 75, 138, 719}); + + dieListe.einfuegenBei(7, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 75, 138, 445, 719}); + + dieListe.einfuegenBei(5, 845); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 445, 719}); + + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 445, 719, 333}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333}); + + dieListe.einfuegenBei(2, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 536, 719, 21, 599, 845, 75, 138, 719, 333}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333}); + + assertTrue("Fehler: Element 599 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(599)); + dieListe.anhaengen(733); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333, 733}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 75, 138, 719, 333, 733, 861}); + + dieListe.einfuegenBei(6, 878); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861}); + + dieListe.einfuegenBei(1, 889); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861}); + + dieListe.anhaengen(939); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939}); + + assertFalse("Fehler: Element 667 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(667)); + dieListe.einfuegenBei(2, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664}); + + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344}); + + dieListe.einfuegenBei(18, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896}); + + dieListe.einfuegenBei(4, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896}); + + dieListe.einfuegenBei(8, 209); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 733, 861, 939, 664, 344, 976, 896}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 861, 939, 664, 344, 976, 896}); + + dieListe.einfuegenBei(2, 35); + Tester.pruefeListenInhalt(dieListe, new int[]{236, 889, 35, 741, 605, 794, 719, 21, 599, 209, 845, 878, 75, 138, 719, 333, 861, 939, 664, 344, 976, 896}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 760); + Tester.pruefeListenInhalt(dieListe, new int[]{760}); + + dieListe.anhaengen(924); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 924}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 924, 276}); + + dieListe.einfuegenBei(1, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 920, 924, 276}); + + dieListe.einfuegenBei(1, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{760, 574, 920, 924, 276}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211, 189}); + + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 920, 924, 276, 528, 900, 211, 189, 328}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 924, 276, 528, 900, 211, 189, 328}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 924, 276, 900, 211, 189, 328}); + + dieListe.einfuegenBei(1, 457); + Tester.pruefeListenInhalt(dieListe, new int[]{574, 457, 924, 276, 900, 211, 189, 328}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 924, 276, 900, 211, 189, 328}); + + dieListe.einfuegenBei(7, 459); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 924, 276, 900, 211, 189, 328, 459}); + + dieListe.einfuegenBei(1, 777); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 924, 276, 900, 211, 189, 328, 459}); + + assertFalse("Fehler: Element 59 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(59)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 924, 900, 211, 189, 328, 459}); + + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 777, 900, 211, 189, 328, 459}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 900, 211, 189, 328, 459}); + + dieListe.einfuegenBei(1, 319); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 328, 459}); + + dieListe.anhaengen(477); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 328, 459, 477}); + + dieListe.einfuegenBei(5, 955); + Tester.pruefeListenInhalt(dieListe, new int[]{457, 319, 900, 211, 189, 955, 328, 459, 477}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 211, 189, 955, 328, 459, 477}); + + assertTrue("Fehler: Element 319 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(319)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 211, 189, 955, 328, 477}); + + assertTrue("Fehler: Element 955 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(955)); + assertFalse("Fehler: Element 839 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(839)); + assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985)); + dieListe.einfuegenBei(2, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 771, 211, 189, 955, 328, 477}); + + assertFalse("Fehler: Element 848 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(848)); + dieListe.einfuegenBei(2, 421); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 900, 421, 771, 211, 189, 955, 328, 477}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 421, 771, 211, 189, 955, 328, 477}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477}); + + assertTrue("Fehler: Element 328 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(328)); + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 852}); + + dieListe.anhaengen(131); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 852, 131}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 131}); + + dieListe.anhaengen(506); + Tester.pruefeListenInhalt(dieListe, new int[]{319, 771, 211, 189, 955, 328, 477, 131, 506}); + + dieListe.einfuegenBei(0, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 319, 771, 211, 189, 955, 328, 477, 131, 506}); + + dieListe.anhaengen(824); + Tester.pruefeListenInhalt(dieListe, new int[]{59, 319, 771, 211, 189, 955, 328, 477, 131, 506, 824}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{16}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + dieListe.einfuegenBei(1, 714); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 714}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{16}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertFalse("Fehler: Element 300 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(300)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{470}); + + assertFalse("Fehler: Element 472 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(472)); + assertFalse("Fehler: Element 603 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(603)); + dieListe.anhaengen(394); + Tester.pruefeListenInhalt(dieListe, new int[]{470, 394}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{470}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(904); + Tester.pruefeListenInhalt(dieListe, new int[]{904}); + + dieListe.anhaengen(504); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 504}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{904}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{774}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 476); + Tester.pruefeListenInhalt(dieListe, new int[]{476}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{132}); + + dieListe.anhaengen(507); + Tester.pruefeListenInhalt(dieListe, new int[]{132, 507}); + + assertTrue("Fehler: Element 507 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(507)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 885); + Tester.pruefeListenInhalt(dieListe, new int[]{885}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{885, 526}); + + assertTrue("Fehler: Element 885 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(885)); + assertFalse("Fehler: Element 436 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(436)); + dieListe.einfuegenBei(2, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{885, 526, 174}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{526, 174}); + + dieListe.einfuegenBei(2, 17); + Tester.pruefeListenInhalt(dieListe, new int[]{526, 174, 17}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 17}); + + dieListe.einfuegenBei(1, 828); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17}); + + dieListe.anhaengen(697); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17, 697}); + + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17, 697, 920}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 828, 17, 920}); + + dieListe.einfuegenBei(1, 518); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 17, 920}); + + dieListe.einfuegenBei(3, 685); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920}); + + dieListe.anhaengen(396); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920, 396}); + + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 17, 920, 396, 763}); + + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + dieListe.einfuegenBei(3, 548); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 17, 920, 396, 763}); + + assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275)); + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 17, 920, 396, 763, 604}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 548, 685, 920, 396, 763, 604}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 828, 685, 920, 396, 763, 604}); + + dieListe.einfuegenBei(2, 345); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 685, 920, 396, 763, 604}); + + dieListe.anhaengen(751); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 685, 920, 396, 763, 604, 751}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 920, 396, 763, 604, 751}); + + assertTrue("Fehler: Element 604 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(604)); + assertFalse("Fehler: Element 953 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(953)); + assertFalse("Fehler: Element 812 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(812)); + dieListe.anhaengen(136); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 518, 345, 828, 920, 396, 763, 604, 751, 136}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(342); + Tester.pruefeListenInhalt(dieListe, new int[]{342}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{771}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{553}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(585); + Tester.pruefeListenInhalt(dieListe, new int[]{585}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 455); + Tester.pruefeListenInhalt(dieListe, new int[]{455}); + + assertFalse("Fehler: Element 286 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(286)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{455, 286}); + + dieListe.einfuegenBei(1, 58); + Tester.pruefeListenInhalt(dieListe, new int[]{455, 58, 286}); + + dieListe.einfuegenBei(0, 438); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 455, 58, 286}); + + dieListe.einfuegenBei(4, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 455, 58, 286, 496}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 58, 286, 496}); + + assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496)); + dieListe.einfuegenBei(1, 162); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 58, 286, 496}); + + dieListe.einfuegenBei(2, 195); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 58, 286, 496}); + + assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 286, 496}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496}); + + dieListe.anhaengen(911); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496, 911}); + + dieListe.anhaengen(986); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 496, 911, 986}); + + dieListe.einfuegenBei(3, 102); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 496, 911, 986}); + + assertFalse("Fehler: Element 979 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(979)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 496, 911}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 911}); + + dieListe.anhaengen(858); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 911, 858}); + + dieListe.einfuegenBei(4, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 911, 858}); + + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 911, 858, 102}); + + dieListe.einfuegenBei(5, 998); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 998, 911, 858, 102}); + + dieListe.einfuegenBei(5, 323); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 858, 102}); + + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.einfuegenBei(8, 721); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 858, 102}); + + dieListe.anhaengen(272); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 858, 102, 272}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 102, 272}); + + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 911, 721, 102, 272, 868}); + + assertFalse("Fehler: Element 20 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(20)); + dieListe.einfuegenBei(7, 8); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 8, 911, 721, 102, 272, 868}); + + dieListe.einfuegenBei(10, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 195, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 162, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868}); + + dieListe.einfuegenBei(1, 375); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 721, 757, 102, 272, 868}); + + dieListe.einfuegenBei(9, 216); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868}); + + dieListe.anhaengen(692); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868, 692}); + + dieListe.anhaengen(875); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875}); + + dieListe.einfuegenBei(7, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875}); + + assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297)); + assertTrue("Fehler: Element 911 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(911)); + dieListe.einfuegenBei(18, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702}); + + assertTrue("Fehler: Element 692 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(692)); + dieListe.einfuegenBei(19, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707, 57}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 702, 707, 57, 896}); + + assertFalse("Fehler: Element 198 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(198)); + assertFalse("Fehler: Element 770 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(770)); + dieListe.einfuegenBei(18, 643); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896}); + + assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102)); + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 162, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 102, 413, 323, 998, 132, 8, 911, 216, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{438, 375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397}); + + assertTrue("Fehler: Element 643 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(643)); + dieListe.anhaengen(85); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.einfuegenBei(5, 794); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 413, 323, 998, 794, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.einfuegenBei(2, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 102, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + dieListe.einfuegenBei(1, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85}); + + assertTrue("Fehler: Element 102 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(102)); + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 692, 875, 643, 702, 707, 57, 896, 397, 85, 397}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397}); + + dieListe.anhaengen(491); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397, 491}); + + dieListe.anhaengen(418); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 57, 896, 397, 85, 397, 491, 418}); + + dieListe.entferneBei(19); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 85, 397, 491, 418}); + + assertFalse("Fehler: Element 177 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(177)); + assertFalse("Fehler: Element 45 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(45)); + assertFalse("Fehler: Element 310 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(310)); + dieListe.entferneBei(21); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418}); + + assertFalse("Fehler: Element 73 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(73)); + dieListe.anhaengen(30); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30}); + + dieListe.einfuegenBei(7, 226); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30}); + + assertFalse("Fehler: Element 155 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(155)); + assertFalse("Fehler: Element 395 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(395)); + dieListe.anhaengen(913); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30, 913}); + + dieListe.anhaengen(885); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 702, 707, 896, 397, 397, 491, 418, 30, 913, 885}); + + dieListe.einfuegenBei(18, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 397, 491, 418, 30, 913, 885}); + + dieListe.entferneBei(23); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885}); + + dieListe.einfuegenBei(11, 448); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885}); + + dieListe.anhaengen(2); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 418, 30, 913, 885, 2}); + + dieListe.entferneBei(25); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.einfuegenBei(12, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 102, 647, 413, 323, 998, 226, 794, 132, 8, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 8, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.einfuegenBei(19, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 911, 721, 757, 272, 868, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + dieListe.einfuegenBei(15, 611); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + assertFalse("Fehler: Element 902 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(902)); + dieListe.einfuegenBei(2, 327); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 327, 647, 413, 323, 998, 226, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + assertFalse("Fehler: Element 366 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(366)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 70, 327, 647, 413, 323, 998, 794, 132, 448, 390, 721, 757, 272, 868, 611, 875, 643, 647, 133, 702, 707, 896, 397, 491, 30, 913, 885, 2}); + + assertFalse("Fehler: Element 319 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(319)); + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 139); + Tester.pruefeListenInhalt(dieListe, new int[]{139}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(364); + Tester.pruefeListenInhalt(dieListe, new int[]{364}); + + assertFalse("Fehler: Element 166 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(166)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 280); + Tester.pruefeListenInhalt(dieListe, new int[]{280}); + + dieListe.einfuegenBei(1, 996); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 996}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{996}); + + assertTrue("Fehler: Element 996 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(996)); + dieListe.einfuegenBei(0, 894); + Tester.pruefeListenInhalt(dieListe, new int[]{894, 996}); + + assertTrue("Fehler: Element 996 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(996)); + dieListe.einfuegenBei(2, 557); + Tester.pruefeListenInhalt(dieListe, new int[]{894, 996, 557}); + + assertFalse("Fehler: Element 980 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(980)); + dieListe.einfuegenBei(0, 472); + Tester.pruefeListenInhalt(dieListe, new int[]{472, 894, 996, 557}); + + dieListe.einfuegenBei(1, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{472, 546, 894, 996, 557}); + + assertFalse("Fehler: Element 788 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(788)); + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.einfuegenBei(0, 31); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 472, 546, 894, 996, 557}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 472, 546, 894, 996}); + + assertTrue("Fehler: Element 894 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(894)); + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 546, 894, 996}); + + assertTrue("Fehler: Element 996 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(996)); + dieListe.einfuegenBei(2, 518); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 546, 518, 894, 996}); + + dieListe.einfuegenBei(1, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 894, 996}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 894, 996, 276}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 546, 518, 996, 276}); + + dieListe.einfuegenBei(2, 388); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 996, 276}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 996, 276, 897}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 276, 897}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 518, 276, 897, 626}); + + assertTrue("Fehler: Element 897 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(897)); + assertTrue("Fehler: Element 388 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(388)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626}); + + assertFalse("Fehler: Element 92 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(92)); + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45}); + + dieListe.anhaengen(307); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45, 307}); + + dieListe.anhaengen(479); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 276, 897, 626, 45, 307, 479}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 626, 45, 307, 479}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479}); + + dieListe.anhaengen(712); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479, 712}); + + dieListe.einfuegenBei(8, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 307, 479, 766, 712}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 546, 897, 45, 479, 766, 712}); + + assertTrue("Fehler: Element 555 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(555)); + dieListe.einfuegenBei(3, 878); + Tester.pruefeListenInhalt(dieListe, new int[]{31, 555, 388, 878, 546, 897, 45, 479, 766, 712}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(419); + Tester.pruefeListenInhalt(dieListe, new int[]{419}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 966); + Tester.pruefeListenInhalt(dieListe, new int[]{966}); + + dieListe.einfuegenBei(1, 116); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116}); + + dieListe.einfuegenBei(0, 856); + Tester.pruefeListenInhalt(dieListe, new int[]{856, 966, 116}); + + dieListe.anhaengen(942); + Tester.pruefeListenInhalt(dieListe, new int[]{856, 966, 116, 942}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116, 942}); + + assertTrue("Fehler: Element 966 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(966)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 116, 247}); + + assertFalse("Fehler: Element 803 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(803)); + dieListe.einfuegenBei(1, 747); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 116, 247}); + + dieListe.anhaengen(338); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 116, 247, 338}); + + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 116, 247, 338, 251}); + + assertFalse("Fehler: Element 67 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(67)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 747, 247, 338, 251}); + + dieListe.einfuegenBei(1, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338, 251}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338}); + + assertTrue("Fehler: Element 966 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(966)); + dieListe.anhaengen(740); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 747, 247, 338, 740}); + + dieListe.einfuegenBei(2, 423); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 747, 247, 338, 740}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 247, 338, 740}); + + assertFalse("Fehler: Element 272 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(272)); + assertTrue("Fehler: Element 740 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(740)); + dieListe.anhaengen(308); + Tester.pruefeListenInhalt(dieListe, new int[]{966, 686, 423, 247, 338, 740, 308}); + + assertTrue("Fehler: Element 338 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(338)); + assertFalse("Fehler: Element 607 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(607)); + assertTrue("Fehler: Element 247 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(247)); + assertFalse("Fehler: Element 109 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(109)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 125); + Tester.pruefeListenInhalt(dieListe, new int[]{125}); + + dieListe.einfuegenBei(0, 887); + Tester.pruefeListenInhalt(dieListe, new int[]{887, 125}); + + assertTrue("Fehler: Element 887 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(887)); + assertTrue("Fehler: Element 887 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(887)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{125}); + + assertTrue("Fehler: Element 125 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(125)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(259); + Tester.pruefeListenInhalt(dieListe, new int[]{259}); + + dieListe.anhaengen(750); + Tester.pruefeListenInhalt(dieListe, new int[]{259, 750}); + + assertFalse("Fehler: Element 268 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(268)); + assertTrue("Fehler: Element 259 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(259)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{259}); + + dieListe.einfuegenBei(1, 456); + Tester.pruefeListenInhalt(dieListe, new int[]{259, 456}); + + dieListe.einfuegenBei(0, 415); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 259, 456}); + + assertFalse("Fehler: Element 797 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(797)); + assertTrue("Fehler: Element 456 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(456)); + dieListe.einfuegenBei(0, 729); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 415, 259, 456}); + + dieListe.einfuegenBei(1, 985); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 985, 415, 259, 456}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 985, 415, 456}); + + dieListe.einfuegenBei(1, 233); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 985, 415, 456}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456}); + + dieListe.einfuegenBei(4, 825); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456, 825}); + + dieListe.einfuegenBei(4, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 233, 415, 456, 651, 825}); + + dieListe.einfuegenBei(1, 733); + Tester.pruefeListenInhalt(dieListe, new int[]{729, 733, 233, 415, 456, 651, 825}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(235); + Tester.pruefeListenInhalt(dieListe, new int[]{235}); + + assertTrue("Fehler: Element 235 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(235)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(84); + Tester.pruefeListenInhalt(dieListe, new int[]{84}); + + dieListe.anhaengen(913); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 913}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{84}); + + dieListe.anhaengen(60); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 60}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{84}); + + dieListe.anhaengen(949); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 949}); + + assertFalse("Fehler: Element 745 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(745)); + dieListe.einfuegenBei(2, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{84, 949, 633}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{619}); + + assertTrue("Fehler: Element 619 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(619)); + dieListe.einfuegenBei(0, 589); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 619}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{589}); + + assertTrue("Fehler: Element 589 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(589)); + dieListe.einfuegenBei(1, 407); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407}); + + dieListe.anhaengen(959); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959}); + + dieListe.einfuegenBei(3, 823); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959, 823}); + + assertTrue("Fehler: Element 823 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(823)); + assertFalse("Fehler: Element 975 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(975)); + dieListe.anhaengen(945); + Tester.pruefeListenInhalt(dieListe, new int[]{589, 407, 959, 823, 945}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(529); + Tester.pruefeListenInhalt(dieListe, new int[]{529}); + + dieListe.anhaengen(258); + Tester.pruefeListenInhalt(dieListe, new int[]{529, 258}); + + assertTrue("Fehler: Element 258 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(258)); + assertFalse("Fehler: Element 384 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(384)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{529}); + + assertTrue("Fehler: Element 529 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(529)); + dieListe.einfuegenBei(1, 770); + Tester.pruefeListenInhalt(dieListe, new int[]{529, 770}); + + assertFalse("Fehler: Element 16 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(16)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{529}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 381); + Tester.pruefeListenInhalt(dieListe, new int[]{381}); + + dieListe.einfuegenBei(1, 342); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342}); + + dieListe.anhaengen(167); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 167}); + + dieListe.einfuegenBei(2, 5); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 5, 167}); + + assertFalse("Fehler: Element 252 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(252)); + assertTrue("Fehler: Element 381 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(381)); + dieListe.einfuegenBei(2, 484); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 484, 5, 167}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 342, 484, 5}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{381, 484, 5}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 5}); + + dieListe.einfuegenBei(2, 724); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 5, 724}); + + dieListe.einfuegenBei(1, 719); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 719, 5, 724}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 719, 5}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 719}); + + dieListe.einfuegenBei(1, 32); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 32, 719}); + + assertTrue("Fehler: Element 719 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(719)); + assertTrue("Fehler: Element 32 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(32)); + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 32, 719, 482}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{484, 32, 719, 482, 262}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{952}); + + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369}); + + dieListe.anhaengen(182); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369, 182}); + + dieListe.anhaengen(516); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369, 182, 516}); + + assertFalse("Fehler: Element 386 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(386)); + dieListe.anhaengen(992); + Tester.pruefeListenInhalt(dieListe, new int[]{952, 369, 182, 516, 992}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{689}); + + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{689, 449}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{449}); + + dieListe.einfuegenBei(1, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{449, 757}); + + assertFalse("Fehler: Element 884 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(884)); + assertTrue("Fehler: Element 449 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(449)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{757}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 521}); + + dieListe.einfuegenBei(2, 517); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 521, 517}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 517}); + + dieListe.einfuegenBei(1, 179); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179, 517}); + + assertTrue("Fehler: Element 517 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(517)); + assertTrue("Fehler: Element 757 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(757)); + dieListe.einfuegenBei(1, 129); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 129, 179, 517}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 129, 179}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179}); + + dieListe.anhaengen(628); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179, 628}); + + dieListe.anhaengen(552); + Tester.pruefeListenInhalt(dieListe, new int[]{757, 179, 628, 552}); + + assertTrue("Fehler: Element 628 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(628)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{955}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(454); + Tester.pruefeListenInhalt(dieListe, new int[]{454}); + + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{454, 116}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{454}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{652}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 158); + Tester.pruefeListenInhalt(dieListe, new int[]{158}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(938); + Tester.pruefeListenInhalt(dieListe, new int[]{938}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 713); + Tester.pruefeListenInhalt(dieListe, new int[]{713}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189}); + + assertTrue("Fehler: Element 189 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(189)); + dieListe.einfuegenBei(2, 699); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189, 699}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189}); + + dieListe.einfuegenBei(2, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{713, 189, 880}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(819); + Tester.pruefeListenInhalt(dieListe, new int[]{819}); + + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{819, 743}); + + dieListe.einfuegenBei(0, 432); + Tester.pruefeListenInhalt(dieListe, new int[]{432, 819, 743}); + + assertTrue("Fehler: Element 432 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(432)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{432, 819}); + + dieListe.einfuegenBei(2, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{432, 819, 91}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{819, 91}); + + assertFalse("Fehler: Element 612 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(612)); + dieListe.einfuegenBei(2, 346); + Tester.pruefeListenInhalt(dieListe, new int[]{819, 91, 346}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 346}); + + dieListe.anhaengen(697); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 346, 697}); + + assertTrue("Fehler: Element 346 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(346)); + assertTrue("Fehler: Element 91 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(91)); + dieListe.einfuegenBei(0, 249); + Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 697}); + + dieListe.einfuegenBei(3, 230); + Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 230, 697}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{249, 91, 346, 230}); + + assertTrue("Fehler: Element 346 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(346)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{91, 346, 230}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 230}); + + dieListe.einfuegenBei(1, 15); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 230}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15}); + + dieListe.anhaengen(230); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 230}); + + dieListe.einfuegenBei(2, 405); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 230}); + + dieListe.anhaengen(497); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 230, 497}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497}); + + dieListe.anhaengen(919); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497, 919}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{346, 15, 405, 497, 919, 108}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 405, 497, 919, 108}); + + dieListe.einfuegenBei(1, 197); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 497, 919, 108}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 497, 108}); + + dieListe.einfuegenBei(3, 538); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 197, 405, 538, 497, 108}); + + dieListe.einfuegenBei(1, 875); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108}); + + assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486)); + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108, 896}); + + assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15)); + dieListe.anhaengen(786); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 497, 108, 896, 786}); + + assertFalse("Fehler: Element 816 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(816)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 197, 405, 538, 108, 896, 786}); + + assertFalse("Fehler: Element 622 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(622)); + assertTrue("Fehler: Element 15 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(15)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 405, 538, 108, 896, 786}); + + dieListe.anhaengen(512); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 405, 538, 108, 896, 786, 512}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{15, 875, 538, 108, 896, 786, 512}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(181); + Tester.pruefeListenInhalt(dieListe, new int[]{181}); + + assertFalse("Fehler: Element 506 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(506)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{42}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 438); + Tester.pruefeListenInhalt(dieListe, new int[]{438}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 970}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.einfuegenBei(1, 948); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 948}); + + dieListe.anhaengen(149); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 948, 149}); + + dieListe.einfuegenBei(1, 167); + Tester.pruefeListenInhalt(dieListe, new int[]{749, 167, 948, 149}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(785); + Tester.pruefeListenInhalt(dieListe, new int[]{785}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{126}); + + assertFalse("Fehler: Element 519 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(519)); + dieListe.anhaengen(864); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 864}); + + dieListe.anhaengen(168); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 864, 168}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 168}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 168, 194}); + + assertTrue("Fehler: Element 194 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(194)); + dieListe.einfuegenBei(3, 113); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 168, 194, 113}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 194, 113}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{126, 194, 113, 110}); + + assertFalse("Fehler: Element 131 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(131)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110}); + + dieListe.anhaengen(927); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 927}); + + dieListe.einfuegenBei(3, 730); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 730, 927}); + + assertFalse("Fehler: Element 103 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(103)); + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{194, 113, 110, 730, 927, 355}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355}); + + assertTrue("Fehler: Element 730 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(730)); + dieListe.anhaengen(365); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365}); + + dieListe.anhaengen(29); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29, 869}); + + dieListe.anhaengen(246); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 355, 365, 29, 869, 246}); + + dieListe.einfuegenBei(4, 508); + Tester.pruefeListenInhalt(dieListe, new int[]{113, 110, 730, 927, 508, 355, 365, 29, 869, 246}); + + dieListe.einfuegenBei(0, 415); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 110, 730, 927, 508, 355, 365, 29, 869, 246}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 869, 246}); + + dieListe.einfuegenBei(8, 506); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246}); + + dieListe.anhaengen(862); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246, 862}); + + dieListe.einfuegenBei(11, 299); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 508, 355, 365, 29, 506, 869, 246, 299, 862}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 355, 365, 29, 506, 869, 246, 299, 862}); + + assertFalse("Fehler: Element 559 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(559)); + dieListe.einfuegenBei(4, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 59, 355, 365, 29, 506, 869, 246, 299, 862}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.einfuegenBei(1, 531); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + dieListe.einfuegenBei(5, 499); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 499, 59, 355, 365, 29, 506, 246, 299, 862}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 113, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{415, 531, 730, 927, 59, 355, 365, 29, 506, 246, 299, 862}); + + assertTrue("Fehler: Element 927 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(927)); + assertFalse("Fehler: Element 221 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(221)); + assertTrue("Fehler: Element 29 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(29)); + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest7.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest7.java new file mode 100644 index 0000000..dce19ea --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest7.java @@ -0,0 +1,2841 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest7. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest7 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 0); + Tester.pruefeListenInhalt(dieListe, new int[]{0}); + + dieListe.einfuegenBei(1, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{0, 922}); + + dieListe.einfuegenBei(2, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{0, 922, 956}); + + dieListe.einfuegenBei(0, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 0, 922, 956}); + + dieListe.einfuegenBei(2, 114); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 0, 114, 922, 956}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 0, 114, 956}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956}); + + assertFalse("Fehler: Element 371 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(371)); + dieListe.anhaengen(215); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 718}); + + dieListe.anhaengen(276); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 718, 276}); + + dieListe.einfuegenBei(4, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 215, 788, 718, 276}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 788, 718, 276}); + + assertTrue("Fehler: Element 788 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(788)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 114, 956, 788, 276}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276}); + + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832}); + + dieListe.anhaengen(102); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102}); + + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102, 7}); + + assertFalse("Fehler: Element 240 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(240)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 956, 788, 276, 832, 102}); + + dieListe.einfuegenBei(0, 393); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 607, 956, 788, 276, 832, 102}); + + dieListe.einfuegenBei(1, 691); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 956, 788, 276, 832, 102}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 276, 832, 102}); + + assertFalse("Fehler: Element 886 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(886)); + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 276, 832, 102, 344}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 102, 344}); + + dieListe.einfuegenBei(5, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 109, 102, 344}); + + assertFalse("Fehler: Element 190 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(190)); + dieListe.anhaengen(970); + Tester.pruefeListenInhalt(dieListe, new int[]{393, 691, 607, 788, 832, 109, 102, 344, 970}); + + assertFalse("Fehler: Element 766 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(766)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 344, 970}); + + dieListe.einfuegenBei(6, 497); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 344, 970}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 344}); + + assertTrue("Fehler: Element 691 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(691)); + dieListe.einfuegenBei(7, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 109, 102, 497, 665, 344}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + dieListe.einfuegenBei(4, 659); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 109, 102, 497, 665, 344}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 109, 497, 665, 344}); + + dieListe.einfuegenBei(5, 493); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 493, 109, 497, 665, 344}); + + assertTrue("Fehler: Element 344 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(344)); + assertTrue("Fehler: Element 691 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(691)); + assertFalse("Fehler: Element 539 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(539)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 832, 659, 493, 109, 497, 344}); + + dieListe.einfuegenBei(3, 819); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 819, 832, 659, 493, 109, 497, 344}); + + assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672)); + dieListe.einfuegenBei(10, 387); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 819, 832, 659, 493, 109, 497, 344, 387}); + + dieListe.einfuegenBei(3, 805); + Tester.pruefeListenInhalt(dieListe, new int[]{691, 607, 788, 805, 819, 832, 659, 493, 109, 497, 344, 387}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 497, 344, 387}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 344, 387}); + + assertTrue("Fehler: Element 819 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(819)); + dieListe.einfuegenBei(10, 722); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 805, 819, 832, 659, 493, 109, 344, 387, 722}); + + assertFalse("Fehler: Element 39 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(39)); + assertFalse("Fehler: Element 739 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(739)); + dieListe.einfuegenBei(2, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 387, 722}); + + dieListe.einfuegenBei(10, 857); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 857, 387, 722}); + + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 857, 387, 722, 96}); + + dieListe.einfuegenBei(10, 37); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 722, 96}); + + dieListe.anhaengen(426); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 722, 96, 426}); + + dieListe.einfuegenBei(13, 503); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 387, 503, 722, 96, 426}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 788, 757, 805, 819, 832, 659, 493, 109, 344, 37, 857, 503, 722, 96, 426}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 825); + Tester.pruefeListenInhalt(dieListe, new int[]{825}); + + assertTrue("Fehler: Element 825 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(825)); + dieListe.anhaengen(627); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627}); + + dieListe.einfuegenBei(0, 945); + Tester.pruefeListenInhalt(dieListe, new int[]{945, 825, 627}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627}); + + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627, 213}); + + dieListe.anhaengen(566); + Tester.pruefeListenInhalt(dieListe, new int[]{825, 627, 213, 566}); + + assertFalse("Fehler: Element 97 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(97)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 213, 566}); + + dieListe.anhaengen(280); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 213, 566, 280}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{627, 566, 280}); + + assertTrue("Fehler: Element 627 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(627)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 280}); + + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 280, 117}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 117}); + + dieListe.anhaengen(755); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 117, 755}); + + dieListe.einfuegenBei(1, 32); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 755}); + + dieListe.anhaengen(695); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 755, 695}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 32, 117, 695}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 117, 695}); + + dieListe.einfuegenBei(1, 53); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 53, 117, 695}); + + dieListe.einfuegenBei(4, 846); + Tester.pruefeListenInhalt(dieListe, new int[]{280, 53, 117, 695, 846}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846}); + + dieListe.anhaengen(242); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515}); + + dieListe.einfuegenBei(6, 471); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471}); + + dieListe.anhaengen(73); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 73}); + + assertTrue("Fehler: Element 846 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(846)); + assertFalse("Fehler: Element 65 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(65)); + dieListe.einfuegenBei(7, 273); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 273, 73}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 471, 73}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 73}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 695, 846, 242, 515, 73, 99}); + + dieListe.einfuegenBei(2, 644); + Tester.pruefeListenInhalt(dieListe, new int[]{53, 117, 644, 695, 846, 242, 515, 73, 99}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 265); + Tester.pruefeListenInhalt(dieListe, new int[]{265}); + + assertFalse("Fehler: Element 478 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(478)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(357); + Tester.pruefeListenInhalt(dieListe, new int[]{357}); + + dieListe.anhaengen(214); + Tester.pruefeListenInhalt(dieListe, new int[]{357, 214}); + + dieListe.einfuegenBei(2, 277); + Tester.pruefeListenInhalt(dieListe, new int[]{357, 214, 277}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{357, 214}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{357}); + + assertFalse("Fehler: Element 291 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(291)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{771}); + + dieListe.anhaengen(619); + Tester.pruefeListenInhalt(dieListe, new int[]{771, 619}); + + dieListe.einfuegenBei(2, 245); + Tester.pruefeListenInhalt(dieListe, new int[]{771, 619, 245}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{689}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(977); + Tester.pruefeListenInhalt(dieListe, new int[]{977}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(318); + Tester.pruefeListenInhalt(dieListe, new int[]{318}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{318, 413}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{413}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(149); + Tester.pruefeListenInhalt(dieListe, new int[]{149}); + + dieListe.anhaengen(114); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 114}); + + dieListe.einfuegenBei(0, 476); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114}); + + dieListe.anhaengen(323); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323}); + + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 940}); + + assertFalse("Fehler: Element 641 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(641)); + dieListe.einfuegenBei(4, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 59, 940}); + + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + dieListe.anhaengen(488); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 323, 59, 940, 488}); + + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + assertFalse("Fehler: Element 390 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(390)); + dieListe.einfuegenBei(3, 614); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 114, 614, 323, 59, 940, 488}); + + dieListe.einfuegenBei(2, 557); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488}); + + dieListe.anhaengen(908); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908}); + + dieListe.anhaengen(155); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908, 155}); + + dieListe.anhaengen(596); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 323, 59, 940, 488, 908, 155, 596}); + + dieListe.einfuegenBei(5, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 557, 114, 614, 416, 323, 59, 940, 488, 908, 155, 596}); + + dieListe.einfuegenBei(2, 832); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 488, 908, 155, 596}); + + dieListe.einfuegenBei(10, 600); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 600, 488, 908, 155, 596}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 940, 600, 908, 155, 596}); + + dieListe.einfuegenBei(9, 466); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596}); + + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596, 670}); + + dieListe.anhaengen(762); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 323, 59, 466, 940, 600, 908, 155, 596, 670, 762}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762}); + + dieListe.einfuegenBei(16, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813}); + + dieListe.anhaengen(759); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 614, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813, 759}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 813, 759}); + + assertFalse("Fehler: Element 783 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(783)); + dieListe.einfuegenBei(15, 961); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759}); + + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(4, 414); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 466, 940, 600, 908, 155, 596, 670, 762, 961, 813, 759, 732}); + + assertTrue("Fehler: Element 832 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(832)); + dieListe.einfuegenBei(14, 879); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(8, 971); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 971, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(9, 743); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.einfuegenBei(5, 836); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 596, 879, 670, 762, 961, 813, 759, 732}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 670, 762, 961, 813, 759, 732}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.entferneBei(22); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 670, 762, 961, 813, 759}); + + dieListe.einfuegenBei(17, 173); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 155, 879, 173, 670, 762, 961, 813, 759}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759}); + + dieListe.einfuegenBei(5, 97); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.einfuegenBei(1, 301); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 961, 813, 759}); + + assertTrue("Fehler: Element 114 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(114)); + dieListe.einfuegenBei(21, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 149, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 940, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759, 974}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{476, 301, 832, 557, 414, 97, 836, 114, 416, 59, 971, 743, 466, 600, 908, 879, 173, 670, 762, 884, 961, 813, 759, 974}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{812}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{812, 57}); + + dieListe.anhaengen(944); + Tester.pruefeListenInhalt(dieListe, new int[]{812, 57, 944}); + + dieListe.anhaengen(400); + Tester.pruefeListenInhalt(dieListe, new int[]{812, 57, 944, 400}); + + assertTrue("Fehler: Element 57 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(57)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{57, 944, 400}); + + assertFalse("Fehler: Element 854 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(854)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{944, 400}); + + dieListe.einfuegenBei(1, 930); + Tester.pruefeListenInhalt(dieListe, new int[]{944, 930, 400}); + + dieListe.anhaengen(626); + Tester.pruefeListenInhalt(dieListe, new int[]{944, 930, 400, 626}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 400, 626}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626}); + + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626, 857}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626}); + + dieListe.anhaengen(321); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 626, 321}); + + assertTrue("Fehler: Element 930 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(930)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 321}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930}); + + dieListe.einfuegenBei(1, 583); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 583}); + + dieListe.anhaengen(118); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 583, 118}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{930, 118}); + + assertFalse("Fehler: Element 152 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(152)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{118}); + + dieListe.einfuegenBei(1, 746); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 746}); + + assertFalse("Fehler: Element 978 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(978)); + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(486); + Tester.pruefeListenInhalt(dieListe, new int[]{486}); + + dieListe.anhaengen(44); + Tester.pruefeListenInhalt(dieListe, new int[]{486, 44}); + + assertTrue("Fehler: Element 486 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(486)); + assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44)); + dieListe.einfuegenBei(1, 973); + Tester.pruefeListenInhalt(dieListe, new int[]{486, 973, 44}); + + dieListe.anhaengen(17); + Tester.pruefeListenInhalt(dieListe, new int[]{486, 973, 44, 17}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17}); + + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 126}); + + dieListe.einfuegenBei(4, 515); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 126, 515}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 515}); + + dieListe.anhaengen(239); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 44, 17, 515, 239}); + + dieListe.einfuegenBei(1, 845); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 17, 515, 239}); + + dieListe.einfuegenBei(3, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 462, 17, 515, 239}); + + dieListe.einfuegenBei(3, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 247, 462, 17, 515, 239}); + + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.einfuegenBei(3, 118); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 247, 462, 17, 515, 239}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 247, 462, 17, 239}); + + dieListe.einfuegenBei(4, 201); + Tester.pruefeListenInhalt(dieListe, new int[]{973, 845, 44, 118, 201, 247, 462, 17, 239}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 118, 201, 247, 462, 17, 239}); + + dieListe.anhaengen(51); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 118, 201, 247, 462, 17, 239, 51}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 201, 247, 462, 17, 239, 51}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{845, 44, 201, 247, 462, 239, 51}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51}); + + dieListe.anhaengen(694); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51, 694}); + + dieListe.anhaengen(700); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 51, 694, 700}); + + assertFalse("Fehler: Element 497 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(497)); + assertFalse("Fehler: Element 475 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(475)); + dieListe.einfuegenBei(5, 264); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 201, 247, 462, 239, 264, 51, 694, 700}); + + dieListe.einfuegenBei(1, 353); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 353, 201, 247, 462, 239, 264, 51, 694, 700}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 353, 201, 247, 462, 239, 264, 694, 700}); + + dieListe.einfuegenBei(1, 974); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 462, 239, 264, 694, 700}); + + dieListe.einfuegenBei(5, 874); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 874, 462, 239, 264, 694, 700}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 874, 239, 264, 694, 700}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 264, 694, 700}); + + dieListe.einfuegenBei(6, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 694, 700}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 700}); + + assertFalse("Fehler: Element 993 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(993)); + dieListe.anhaengen(882); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 700, 882}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 882}); + + assertFalse("Fehler: Element 680 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(680)); + dieListe.einfuegenBei(2, 340); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 340, 353, 201, 247, 239, 26, 264, 882}); + + assertFalse("Fehler: Element 896 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(896)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 247, 239, 26, 264, 882}); + + dieListe.einfuegenBei(4, 389); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 26, 264, 882}); + + dieListe.anhaengen(299); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 26, 264, 882, 299}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299}); + + dieListe.einfuegenBei(3, 195); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 389, 247, 239, 264, 882, 299}); + + assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195)); + dieListe.anhaengen(613); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 389, 247, 239, 264, 882, 299, 613}); + + dieListe.einfuegenBei(5, 611); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 195, 201, 611, 389, 247, 239, 264, 882, 299, 613}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613}); + + dieListe.anhaengen(242); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242}); + + assertFalse("Fehler: Element 75 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(75)); + assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389)); + dieListe.einfuegenBei(13, 140); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140}); + + assertFalse("Fehler: Element 388 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(388)); + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 288}); + + assertFalse("Fehler: Element 759 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(759)); + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140}); + + dieListe.anhaengen(352); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352}); + + dieListe.anhaengen(363); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 611, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363}); + + assertTrue("Fehler: Element 264 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(264)); + dieListe.anhaengen(218); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 644}); + + dieListe.einfuegenBei(16, 756); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644}); + + dieListe.anhaengen(900); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644, 900}); + + dieListe.einfuegenBei(15, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 183, 218, 756, 644, 900}); + + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 363, 218, 756, 644, 900}); + + dieListe.einfuegenBei(14, 348); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 974, 353, 201, 389, 247, 239, 264, 882, 299, 613, 242, 140, 352, 348, 363, 218, 756, 644, 900}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{43}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 504); + Tester.pruefeListenInhalt(dieListe, new int[]{504}); + + dieListe.einfuegenBei(1, 667); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667}); + + assertFalse("Fehler: Element 187 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(187)); + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452}); + + dieListe.anhaengen(647); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 647}); + + dieListe.einfuegenBei(3, 463); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 463, 647}); + + dieListe.einfuegenBei(3, 826); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 667, 452, 826, 463, 647}); + + dieListe.einfuegenBei(1, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 667, 452, 826, 463, 647}); + + dieListe.einfuegenBei(5, 90); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 667, 452, 826, 90, 463, 647}); + + assertTrue("Fehler: Element 647 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(647)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 452, 826, 90, 463, 647}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{504, 532, 452, 826, 90, 647}); + + assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265)); + dieListe.einfuegenBei(0, 669); + Tester.pruefeListenInhalt(dieListe, new int[]{669, 504, 532, 452, 826, 90, 647}); + + assertFalse("Fehler: Element 687 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(687)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 454); + Tester.pruefeListenInhalt(dieListe, new int[]{454}); + + dieListe.einfuegenBei(0, 620); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 454}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 454, 450}); + + dieListe.anhaengen(955); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 454, 450, 955}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 450, 955}); + + dieListe.anhaengen(292); + Tester.pruefeListenInhalt(dieListe, new int[]{620, 450, 955, 292}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 753); + Tester.pruefeListenInhalt(dieListe, new int[]{753}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 61); + Tester.pruefeListenInhalt(dieListe, new int[]{61}); + + assertFalse("Fehler: Element 938 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(938)); + dieListe.anhaengen(705); + Tester.pruefeListenInhalt(dieListe, new int[]{61, 705}); + + dieListe.einfuegenBei(2, 124); + Tester.pruefeListenInhalt(dieListe, new int[]{61, 705, 124}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.anhaengen(920); + Tester.pruefeListenInhalt(dieListe, new int[]{61, 705, 124, 920}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{705, 124, 920}); + + dieListe.einfuegenBei(0, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920}); + + dieListe.anhaengen(963); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963}); + + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6}); + + dieListe.anhaengen(749); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6, 749}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{569, 705, 124, 920, 963, 6, 749, 883}); + + dieListe.einfuegenBei(0, 875); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 963, 6, 749, 883}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 6, 749, 883}); + + dieListe.einfuegenBei(5, 554); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 554, 6, 749, 883}); + + assertFalse("Fehler: Element 165 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(165)); + assertFalse("Fehler: Element 444 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(444)); + dieListe.einfuegenBei(6, 313); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 124, 920, 554, 313, 6, 749, 883}); + + dieListe.einfuegenBei(3, 949); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 6, 749, 883}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 6, 883}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 949, 124, 920, 554, 313, 883}); + + dieListe.einfuegenBei(3, 449); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 920, 554, 313, 883}); + + assertFalse("Fehler: Element 486 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(486)); + assertTrue("Fehler: Element 705 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(705)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883}); + + dieListe.einfuegenBei(9, 788); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883, 788}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 949, 124, 554, 313, 883, 788, 170}); + + dieListe.einfuegenBei(4, 10); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 554, 313, 883, 788, 170}); + + dieListe.anhaengen(431); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 554, 313, 883, 788, 170, 431}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + assertFalse("Fehler: Element 542 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(542)); + assertFalse("Fehler: Element 726 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(726)); + assertTrue("Fehler: Element 875 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(875)); + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + dieListe.einfuegenBei(7, 949); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 554, 313, 883, 788, 170, 431}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 554, 313, 883, 788, 431}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 569, 705, 449, 10, 949, 124, 949, 313, 883, 788, 431}); + + assertTrue("Fehler: Element 875 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(875)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 788, 431}); + + dieListe.einfuegenBei(9, 600); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431}); + + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368)); + dieListe.anhaengen(212); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 212}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431}); + + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575}); + + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575, 157}); + + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 949, 313, 883, 600, 788, 431, 575, 157, 838}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 157, 838}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 157}); + + dieListe.einfuegenBei(12, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 980, 157}); + + dieListe.anhaengen(677); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 431, 575, 980, 157, 677}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 788, 575, 980, 157, 677}); + + dieListe.einfuegenBei(9, 693); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677}); + + dieListe.anhaengen(37); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37}); + + dieListe.anhaengen(212); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37, 212}); + + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 693, 788, 575, 980, 157, 677, 37, 212, 838}); + + dieListe.einfuegenBei(9, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 980, 157, 677, 37, 212, 838}); + + dieListe.anhaengen(971); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 980, 157, 677, 37, 212, 838, 971}); + + dieListe.einfuegenBei(13, 708); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 677, 37, 212, 838, 971}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 37, 212, 838, 971}); + + dieListe.einfuegenBei(16, 67); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 157, 67, 37, 212, 838, 971}); + + dieListe.einfuegenBei(15, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + + dieListe.einfuegenBei(6, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 949, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + + dieListe.einfuegenBei(4, 977); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 977, 949, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + + assertTrue("Fehler: Element 600 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(600)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{875, 705, 449, 10, 977, 124, 525, 313, 883, 600, 427, 693, 788, 575, 708, 980, 133, 157, 67, 37, 212, 838, 971}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(834); + Tester.pruefeListenInhalt(dieListe, new int[]{834}); + + assertTrue("Fehler: Element 834 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(834)); + dieListe.einfuegenBei(0, 657); + Tester.pruefeListenInhalt(dieListe, new int[]{657, 834}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{657}); + + assertTrue("Fehler: Element 657 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(657)); + dieListe.einfuegenBei(1, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{657, 884}); + + dieListe.anhaengen(45); + Tester.pruefeListenInhalt(dieListe, new int[]{657, 884, 45}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45}); + + dieListe.anhaengen(644); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644}); + + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413}); + + assertTrue("Fehler: Element 644 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(686); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413, 686}); + + assertFalse("Fehler: Element 804 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(804)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 45, 644, 413}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413}); + + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881}); + + dieListe.einfuegenBei(4, 685); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 685}); + + assertFalse("Fehler: Element 87 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(87)); + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881}); + + dieListe.anhaengen(897); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 897}); + + dieListe.anhaengen(300); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 644, 413, 881, 897, 300}); + + dieListe.einfuegenBei(1, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 396, 644, 413, 881, 897, 300}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + assertTrue("Fehler: Element 413 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(413)); + assertTrue("Fehler: Element 884 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(884)); + dieListe.einfuegenBei(6, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 396, 644, 413, 881, 897, 568, 300}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 173); + Tester.pruefeListenInhalt(dieListe, new int[]{173}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 843); + Tester.pruefeListenInhalt(dieListe, new int[]{843}); + + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + assertTrue("Fehler: Element 843 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(843)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(914); + Tester.pruefeListenInhalt(dieListe, new int[]{914}); + + dieListe.einfuegenBei(0, 814); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 914}); + + dieListe.einfuegenBei(1, 74); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914}); + + assertFalse("Fehler: Element 787 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(787)); + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914, 846}); + + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{814, 74, 914, 846, 95}); + + dieListe.einfuegenBei(0, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 846, 95}); + + dieListe.einfuegenBei(6, 84); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 846, 95, 84}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 814, 74, 914, 95, 84}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 74, 914, 95, 84}); + + assertFalse("Fehler: Element 182 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(182)); + assertFalse("Fehler: Element 495 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(495)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 74, 914, 84}); + + dieListe.einfuegenBei(1, 556); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84}); + + dieListe.einfuegenBei(1, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 813, 556, 74, 914, 84}); + + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 813, 556, 74, 914, 84, 640}); + + assertFalse("Fehler: Element 601 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(601)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640}); + + dieListe.einfuegenBei(1, 365); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640}); + + dieListe.anhaengen(126); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 126}); + + dieListe.einfuegenBei(7, 955); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126}); + + dieListe.anhaengen(309); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309}); + + assertFalse("Fehler: Element 638 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(638)); + assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765)); + dieListe.anhaengen(551); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309, 551}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 126, 309, 551, 347}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 309, 551, 347}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 551, 347}); + + dieListe.anhaengen(995); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 365, 556, 74, 914, 84, 640, 955, 551, 347, 995}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 551, 347, 995}); + + assertTrue("Fehler: Element 640 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(640)); + assertFalse("Fehler: Element 864 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(864)); + dieListe.einfuegenBei(7, 115); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 115, 551, 347, 995}); + + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 74, 914, 84, 640, 955, 115, 551, 347, 995, 568}); + + dieListe.einfuegenBei(2, 54); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 84, 640, 955, 115, 551, 347, 995, 568}); + + dieListe.einfuegenBei(5, 939); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 939, 84, 640, 955, 115, 551, 347, 995, 568}); + + assertTrue("Fehler: Element 84 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(84)); + dieListe.einfuegenBei(8, 790); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 914, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568}); + + assertTrue("Fehler: Element 84 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(84)); + dieListe.anhaengen(589); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 74, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589}); + + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 551, 347, 995, 568, 589, 83}); + + dieListe.einfuegenBei(9, 267); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83}); + + dieListe.anhaengen(131); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + + dieListe.einfuegenBei(6, 602); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 602, 790, 955, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 602, 790, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + + dieListe.einfuegenBei(6, 397); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 556, 54, 939, 84, 640, 397, 602, 790, 115, 267, 551, 347, 995, 568, 589, 83, 131}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 781); + Tester.pruefeListenInhalt(dieListe, new int[]{781}); + + dieListe.einfuegenBei(0, 964); + Tester.pruefeListenInhalt(dieListe, new int[]{964, 781}); + + dieListe.einfuegenBei(0, 380); + Tester.pruefeListenInhalt(dieListe, new int[]{380, 964, 781}); + + dieListe.einfuegenBei(0, 991); + Tester.pruefeListenInhalt(dieListe, new int[]{991, 380, 964, 781}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{92, 854}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{854}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(24); + Tester.pruefeListenInhalt(dieListe, new int[]{24}); + + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertFalse("Fehler: Element 769 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(769)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 739); + Tester.pruefeListenInhalt(dieListe, new int[]{739}); + + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + assertTrue("Fehler: Element 739 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(739)); + dieListe.einfuegenBei(1, 609); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646}); + + assertFalse("Fehler: Element 697 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(697)); + dieListe.anhaengen(611); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646, 611}); + + dieListe.anhaengen(159); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 609, 646, 611, 159}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 646, 611, 159}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159}); + + dieListe.einfuegenBei(3, 86); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159, 86}); + + assertTrue("Fehler: Element 159 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(159)); + dieListe.anhaengen(535); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 159, 86, 535}); + + dieListe.einfuegenBei(2, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535}); + + dieListe.anhaengen(445); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535, 445}); + + assertFalse("Fehler: Element 794 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(794)); + dieListe.anhaengen(153); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 611, 607, 159, 86, 535, 445, 153}); + + dieListe.einfuegenBei(1, 866); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 445, 153}); + + dieListe.anhaengen(574); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 445, 153, 574}); + + dieListe.einfuegenBei(7, 169); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707}); + + dieListe.einfuegenBei(0, 911); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707}); + + assertFalse("Fehler: Element 476 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(476)); + dieListe.anhaengen(353); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707, 353}); + + dieListe.einfuegenBei(1, 459); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 159, 86, 535, 169, 445, 153, 574, 707, 353}); + + dieListe.einfuegenBei(6, 431); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 574, 707, 353}); + + assertFalse("Fehler: Element 672 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(672)); + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 707, 353}); + + dieListe.einfuegenBei(0, 87); + Tester.pruefeListenInhalt(dieListe, new int[]{87, 911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 153, 707, 353}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{87, 911, 459, 739, 866, 611, 607, 431, 159, 86, 535, 169, 445, 707, 353}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(83); + Tester.pruefeListenInhalt(dieListe, new int[]{83}); + + assertFalse("Fehler: Element 893 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(893)); + dieListe.einfuegenBei(0, 421); + Tester.pruefeListenInhalt(dieListe, new int[]{421, 83}); + + assertFalse("Fehler: Element 714 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(714)); + dieListe.einfuegenBei(0, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 421, 83}); + + assertFalse("Fehler: Element 736 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(736)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 421}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{421}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 639); + Tester.pruefeListenInhalt(dieListe, new int[]{639}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 311); + Tester.pruefeListenInhalt(dieListe, new int[]{311}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{175}); + + assertFalse("Fehler: Element 352 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(352)); + dieListe.anhaengen(759); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 759}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{175}); + + assertTrue("Fehler: Element 175 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(175)); + assertFalse("Fehler: Element 203 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(203)); + assertTrue("Fehler: Element 175 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(175)); + dieListe.anhaengen(117); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 117}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 117, 664}); + + dieListe.einfuegenBei(3, 1); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 117, 664, 1}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 661); + Tester.pruefeListenInhalt(dieListe, new int[]{661}); + + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{661, 285}); + + dieListe.einfuegenBei(2, 234); + Tester.pruefeListenInhalt(dieListe, new int[]{661, 285, 234}); + + assertTrue("Fehler: Element 234 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(234)); + dieListe.anhaengen(249); + Tester.pruefeListenInhalt(dieListe, new int[]{661, 285, 234, 249}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 234, 249}); + + assertFalse("Fehler: Element 227 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(227)); + assertFalse("Fehler: Element 735 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(735)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 234}); + + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{285, 234, 769}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 769}); + + dieListe.einfuegenBei(1, 617); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 617, 769}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 617}); + + assertTrue("Fehler: Element 234 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(234)); + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 617, 998}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{234, 998}); + + assertFalse("Fehler: Element 591 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(591)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{998}); + + dieListe.einfuegenBei(1, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976}); + + assertTrue("Fehler: Element 976 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474}); + + assertFalse("Fehler: Element 806 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(806)); + assertTrue("Fehler: Element 976 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(976)); + dieListe.anhaengen(666); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666}); + + dieListe.anhaengen(983); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666, 983}); + + dieListe.anhaengen(428); + Tester.pruefeListenInhalt(dieListe, new int[]{998, 976, 474, 666, 983, 428}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 666, 983, 428}); + + assertFalse("Fehler: Element 517 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(517)); + dieListe.anhaengen(778); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 666, 983, 428, 778}); + + dieListe.einfuegenBei(2, 424); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 474, 424, 666, 983, 428, 778}); + + assertTrue("Fehler: Element 424 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(424)); + assertFalse("Fehler: Element 891 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(891)); + assertFalse("Fehler: Element 81 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(81)); + dieListe.einfuegenBei(1, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 666, 983, 428, 778}); + + assertFalse("Fehler: Element 809 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(809)); + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 666, 983, 428, 778, 623}); + + dieListe.einfuegenBei(4, 412); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 778, 623}); + + dieListe.anhaengen(321); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 778, 623, 321}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 623, 321}); + + dieListe.einfuegenBei(10, 658); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 666, 983, 428, 623, 321, 658}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 321, 658}); + + assertFalse("Fehler: Element 924 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(924)); + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 321, 658, 719}); + + dieListe.einfuegenBei(8, 367); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 719}); + + dieListe.einfuegenBei(12, 35); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 719, 35}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 623, 367, 321, 658, 35}); + + dieListe.einfuegenBei(7, 973); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35}); + + assertTrue("Fehler: Element 412 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(412)); + dieListe.anhaengen(840); + Tester.pruefeListenInhalt(dieListe, new int[]{976, 208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840}); + + dieListe.anhaengen(95); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 658, 35, 840, 95}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 623, 367, 321, 35, 840, 95}); + + dieListe.einfuegenBei(7, 499); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 840, 95}); + + assertFalse("Fehler: Element 599 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(599)); + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95}); + + dieListe.anhaengen(448); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95, 448}); + + assertFalse("Fehler: Element 296 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(296)); + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 367, 321, 35, 95, 448, 105}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 321, 35, 95, 448, 105}); + + assertFalse("Fehler: Element 903 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(903)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 321, 95, 448, 105}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 95, 448, 105}); + + dieListe.einfuegenBei(12, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 412, 983, 428, 973, 499, 623, 95, 448, 105, 42}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 95, 448, 105, 42}); + + assertFalse("Fehler: Element 317 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(317)); + assertTrue("Fehler: Element 42 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(42)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 448, 105, 42}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 499, 623, 448, 105, 42, 874}); + + assertFalse("Fehler: Element 95 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(95)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 474, 424, 983, 428, 973, 623, 448, 105, 42, 874}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 983, 428, 973, 623, 448, 105, 42, 874}); + + dieListe.einfuegenBei(2, 120); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 120, 983, 428, 973, 623, 448, 105, 42, 874}); + + dieListe.einfuegenBei(4, 683); + Tester.pruefeListenInhalt(dieListe, new int[]{208, 424, 120, 983, 683, 428, 973, 623, 448, 105, 42, 874}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{388}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 417); + Tester.pruefeListenInhalt(dieListe, new int[]{417}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85}); + + dieListe.einfuegenBei(0, 3); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 85}); + + dieListe.anhaengen(725); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 85, 725}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707}); + + assertFalse("Fehler: Element 523 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(523)); + assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707)); + dieListe.anhaengen(455); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707, 455}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{3, 725, 707, 455, 196}); + + assertFalse("Fehler: Element 290 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(290)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 196}); + + dieListe.einfuegenBei(3, 454); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 454, 196}); + + dieListe.anhaengen(489); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 454, 196, 489}); + + assertTrue("Fehler: Element 707 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(707)); + assertTrue("Fehler: Element 196 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(196)); + dieListe.einfuegenBei(3, 772); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489}); + + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672}); + + assertFalse("Fehler: Element 368 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(368)); + assertTrue("Fehler: Element 489 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(489)); + assertTrue("Fehler: Element 672 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(672)); + dieListe.anhaengen(79); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672, 79}); + + dieListe.anhaengen(219); + Tester.pruefeListenInhalt(dieListe, new int[]{725, 707, 455, 772, 454, 196, 489, 672, 79, 219}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(354); + Tester.pruefeListenInhalt(dieListe, new int[]{354}); + + dieListe.einfuegenBei(1, 780); + Tester.pruefeListenInhalt(dieListe, new int[]{354, 780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(221); + Tester.pruefeListenInhalt(dieListe, new int[]{221}); + + dieListe.einfuegenBei(0, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{92, 221}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.einfuegenBei(0, 799); + Tester.pruefeListenInhalt(dieListe, new int[]{799, 92}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{92}); + + dieListe.einfuegenBei(1, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{92, 588}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(879); + Tester.pruefeListenInhalt(dieListe, new int[]{879}); + + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409}); + + assertFalse("Fehler: Element 982 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(982)); + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688}); + + dieListe.anhaengen(377); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 377}); + + dieListe.einfuegenBei(3, 763); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 763, 377}); + + assertFalse("Fehler: Element 206 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(206)); + assertFalse("Fehler: Element 461 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(461)); + dieListe.einfuegenBei(4, 306); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 409, 688, 763, 306, 377}); + + dieListe.einfuegenBei(1, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 409, 688, 763, 306, 377}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 306, 377}); + + dieListe.einfuegenBei(4, 148); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377, 675}); + + dieListe.einfuegenBei(7, 893); + Tester.pruefeListenInhalt(dieListe, new int[]{879, 175, 688, 763, 148, 306, 377, 893, 675}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 688, 763, 148, 306, 377, 893, 675}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{175, 688, 763, 306, 377, 893, 675}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 377, 893, 675}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 675}); + + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + dieListe.einfuegenBei(4, 97); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675}); + + assertFalse("Fehler: Element 348 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(348)); + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675, 868}); + + dieListe.anhaengen(688); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 763, 306, 893, 97, 675, 868, 688}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{688, 306, 893, 97, 675, 868, 688}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 692); + Tester.pruefeListenInhalt(dieListe, new int[]{692}); + + dieListe.einfuegenBei(0, 130); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692}); + + dieListe.einfuegenBei(0, 541); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692}); + + dieListe.anhaengen(92); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92}); + + dieListe.einfuegenBei(4, 695); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 695}); + + dieListe.einfuegenBei(4, 157); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 157, 695}); + + assertTrue("Fehler: Element 692 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(692)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{541, 130, 692, 92, 695}); + + assertTrue("Fehler: Element 541 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(541)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 695}); + + dieListe.anhaengen(170); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 695, 170}); + + dieListe.einfuegenBei(3, 159); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 159, 695, 170}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 692, 92, 159, 170}); + + dieListe.einfuegenBei(1, 7); + Tester.pruefeListenInhalt(dieListe, new int[]{130, 7, 692, 92, 159, 170}); + + assertFalse("Fehler: Element 216 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(216)); + dieListe.einfuegenBei(0, 828); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170}); + + assertFalse("Fehler: Element 913 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(913)); + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526, 634}); + + dieListe.anhaengen(576); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 7, 692, 92, 159, 170, 526, 634, 576}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 692, 92, 159, 170, 526, 634, 576}); + + dieListe.einfuegenBei(2, 967); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576}); + + dieListe.anhaengen(530); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530}); + + dieListe.anhaengen(612); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 612}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530}); + + dieListe.einfuegenBei(1, 941); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530}); + + assertTrue("Fehler: Element 828 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(828)); + assertTrue("Fehler: Element 941 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(941)); + dieListe.anhaengen(220); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 220}); + + dieListe.anhaengen(11); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 92, 159, 170, 526, 634, 576, 530, 220, 11}); + + assertFalse("Fehler: Element 734 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(734)); + dieListe.einfuegenBei(5, 335); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 335, 92, 159, 170, 526, 634, 576, 530, 220, 11}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 941, 130, 967, 692, 335, 159, 170, 526, 634, 576, 530, 220, 11}); + + assertTrue("Fehler: Element 130 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(130)); + dieListe.einfuegenBei(1, 469); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 469, 941, 130, 967, 692, 335, 159, 170, 526, 634, 576, 530, 220, 11}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 469, 941, 130, 967, 692, 335, 159, 170, 526, 634, 530, 220, 11}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 151); + Tester.pruefeListenInhalt(dieListe, new int[]{151}); + + dieListe.einfuegenBei(0, 709); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 151}); + + assertTrue("Fehler: Element 151 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(151)); + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 151, 262}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262}); + + assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262)); + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21, 502}); + + dieListe.anhaengen(527); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21, 502, 527}); + + dieListe.anhaengen(850); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 262, 21, 502, 527, 850}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 21, 502, 527, 850}); + + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{709, 502, 527, 850}); + + assertFalse("Fehler: Element 584 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(584)); + dieListe.einfuegenBei(0, 364); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850}); + + dieListe.anhaengen(89); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 89}); + + dieListe.anhaengen(710); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 89, 710}); + + assertTrue("Fehler: Element 710 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(710)); + dieListe.einfuegenBei(5, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 850, 185, 89, 710}); + + dieListe.einfuegenBei(4, 862); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710}); + + dieListe.anhaengen(24); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24}); + + assertTrue("Fehler: Element 364 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(364)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391}); + + assertTrue("Fehler: Element 850 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(850)); + assertTrue("Fehler: Element 185 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(185)); + dieListe.anhaengen(355); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391, 355}); + + dieListe.anhaengen(174); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 24, 391, 355, 174}); + + dieListe.einfuegenBei(9, 732); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 174}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 174, 137}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 185, 89, 710, 732, 24, 391, 355, 137}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326}); + + dieListe.anhaengen(883); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883}); + + dieListe.einfuegenBei(4, 60); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883}); + + dieListe.anhaengen(140); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140}); + + assertFalse("Fehler: Element 792 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(792)); + dieListe.einfuegenBei(5, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 368, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 391, 355, 137, 326, 883, 140}); + + dieListe.einfuegenBei(11, 236); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + assertTrue("Fehler: Element 326 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(326)); + dieListe.einfuegenBei(8, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 89, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 709, 502, 527, 60, 862, 850, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.einfuegenBei(6, 120); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 710, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 137, 326, 883, 140}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 326, 883, 140}); + + dieListe.anhaengen(234); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 502, 527, 60, 862, 850, 120, 78, 732, 24, 236, 391, 355, 326, 883, 140, 234}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{931}); + + dieListe.einfuegenBei(0, 103); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 931}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 931, 707}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 931}); + + dieListe.einfuegenBei(0, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 103, 931}); + + dieListe.anhaengen(428); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 103, 931, 428}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 103, 931, 428, 463}); + + dieListe.einfuegenBei(0, 128); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 103, 931, 428, 463}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 103, 931, 428, 463, 689}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689}); + + dieListe.anhaengen(135); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135, 99}); + + dieListe.anhaengen(192); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 689, 135, 99, 192}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 135, 99, 192}); + + dieListe.einfuegenBei(7, 905); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 77, 931, 428, 463, 135, 99, 905, 192}); + + dieListe.einfuegenBei(1, 44); + Tester.pruefeListenInhalt(dieListe, new int[]{128, 44, 77, 931, 428, 463, 135, 99, 905, 192}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 99, 905, 192}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 905, 192}); + + assertFalse("Fehler: Element 580 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(580)); + dieListe.einfuegenBei(8, 815); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 135, 905, 192, 815}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 905, 192, 815}); + + dieListe.einfuegenBei(6, 300); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 463, 905, 300, 192, 815}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 77, 931, 428, 905, 300, 192, 815}); + + dieListe.einfuegenBei(1, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815}); + + dieListe.anhaengen(672); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672}); + + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575}); + + assertFalse("Fehler: Element 670 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(670)); + dieListe.anhaengen(133); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133, 967}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 672, 575, 133}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44)); + assertFalse("Fehler: Element 985 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(985)); + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 575, 133}); + + assertTrue("Fehler: Element 428 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(428)); + dieListe.anhaengen(906); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 905, 300, 192, 815, 575, 133, 906}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + assertFalse("Fehler: Element 793 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(793)); + dieListe.einfuegenBei(5, 789); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906}); + + assertTrue("Fehler: Element 906 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(906)); + dieListe.anhaengen(548); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548}); + + dieListe.anhaengen(471); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548, 471}); + + assertTrue("Fehler: Element 300 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(300)); + dieListe.einfuegenBei(15, 540); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 192, 815, 575, 133, 906, 548, 471, 540}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 815, 575, 133, 906, 548, 471, 540}); + + assertFalse("Fehler: Element 541 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(541)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540}); + + dieListe.anhaengen(999); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999}); + + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{44, 607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999, 382}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 77, 931, 428, 789, 905, 300, 575, 133, 906, 548, 471, 540, 999, 382}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{449}); + + assertFalse("Fehler: Element 884 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(884)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(948); + Tester.pruefeListenInhalt(dieListe, new int[]{948}); + + dieListe.einfuegenBei(1, 728); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728}); + + assertTrue("Fehler: Element 948 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(948)); + dieListe.anhaengen(890); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890}); + + dieListe.einfuegenBei(3, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382}); + + dieListe.einfuegenBei(4, 168); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168}); + + assertTrue("Fehler: Element 890 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(890)); + dieListe.anhaengen(849); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 849}); + + assertTrue("Fehler: Element 948 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(948)); + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168}); + + dieListe.anhaengen(225); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225}); + + dieListe.einfuegenBei(6, 56); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225, 56}); + + dieListe.einfuegenBei(6, 256); + Tester.pruefeListenInhalt(dieListe, new int[]{948, 728, 890, 382, 168, 225, 256, 56}); + + dieListe.einfuegenBei(0, 47); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 168, 225, 256, 56}); + + dieListe.einfuegenBei(5, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56}); + + dieListe.anhaengen(867); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56, 867}); + + dieListe.anhaengen(497); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497}); + + dieListe.einfuegenBei(8, 780); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497}); + + dieListe.anhaengen(11); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 948, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497, 11}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 780, 256, 56, 867, 497, 11}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497, 11}); + + dieListe.anhaengen(832); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 723, 168, 225, 256, 56, 867, 497, 11, 832}); + + dieListe.einfuegenBei(4, 283); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 382, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832}); + + dieListe.anhaengen(453); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 168, 225, 256, 56, 867, 497, 11, 832, 453}); + + dieListe.einfuegenBei(5, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 11, 832, 453}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 453}); + + dieListe.anhaengen(859); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 453, 859}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859}); + + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.anhaengen(793); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793}); + + assertTrue("Fehler: Element 598 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(598)); + dieListe.anhaengen(180); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.einfuegenBei(1, 420); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 392}); + + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(7, 593); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 420, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180}); + + dieListe.einfuegenBei(17, 832); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 723, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832}); + + assertTrue("Fehler: Element 832 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(832)); + dieListe.einfuegenBei(4, 505); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 859, 793, 180, 832}); + + dieListe.einfuegenBei(14, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832}); + + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631}); + + dieListe.anhaengen(534); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534}); + + dieListe.einfuegenBei(5, 395); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534, 718}); + + dieListe.anhaengen(144); + Tester.pruefeListenInhalt(dieListe, new int[]{47, 728, 890, 283, 505, 395, 598, 593, 168, 225, 256, 56, 867, 497, 832, 19, 859, 793, 180, 832, 631, 534, 718, 144}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(752); + Tester.pruefeListenInhalt(dieListe, new int[]{752}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 885); + Tester.pruefeListenInhalt(dieListe, new int[]{885}); + + assertFalse("Fehler: Element 533 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(533)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(868); + Tester.pruefeListenInhalt(dieListe, new int[]{868}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 490}); + + dieListe.einfuegenBei(1, 276); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 276, 490}); + + dieListe.einfuegenBei(2, 339); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 276, 339, 490}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 339, 490}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 339}); + + dieListe.einfuegenBei(2, 990); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 339, 990}); + + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{868, 990}); + + dieListe.einfuegenBei(0, 185); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 990}); + + assertFalse("Fehler: Element 725 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(725)); + dieListe.einfuegenBei(2, 738); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 738, 990}); + + assertFalse("Fehler: Element 615 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(615)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868, 990}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 868}); + + assertTrue("Fehler: Element 868 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(868)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{185}); + + assertTrue("Fehler: Element 185 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(185)); + dieListe.einfuegenBei(0, 622); + Tester.pruefeListenInhalt(dieListe, new int[]{622, 185}); + + assertFalse("Fehler: Element 668 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(668)); + dieListe.anhaengen(637); + Tester.pruefeListenInhalt(dieListe, new int[]{622, 185, 637}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{622, 185, 637, 718}); + + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + assertTrue("Fehler: Element 718 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(718)); + assertFalse("Fehler: Element 442 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(442)); + assertFalse("Fehler: Element 419 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(419)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 637, 718}); + + dieListe.einfuegenBei(3, 92); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 637, 718, 92}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{185, 718, 92}); + + assertFalse("Fehler: Element 590 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(590)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 92}); + + dieListe.anhaengen(597); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 92, 597}); + + dieListe.einfuegenBei(1, 401); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 401, 92, 597}); + + dieListe.einfuegenBei(3, 937); + Tester.pruefeListenInhalt(dieListe, new int[]{718, 401, 92, 937, 597}); + + dieListe.einfuegenBei(0, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 401, 92, 937, 597}); + + assertTrue("Fehler: Element 597 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(597)); + dieListe.anhaengen(251); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 401, 92, 937, 597, 251}); + + dieListe.einfuegenBei(2, 492); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251}); + + dieListe.anhaengen(704); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251, 704}); + + assertTrue("Fehler: Element 401 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(401)); + assertFalse("Fehler: Element 681 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(681)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{239, 718, 492, 401, 92, 937, 597, 251}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{799}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{799, 137}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{799}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{262}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 403}); + + dieListe.einfuegenBei(2, 118); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 403, 118}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118}); + + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905}); + + dieListe.einfuegenBei(3, 135); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135}); + + assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118)); + dieListe.anhaengen(391); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135, 391}); + + dieListe.anhaengen(452); + Tester.pruefeListenInhalt(dieListe, new int[]{403, 118, 905, 135, 391, 452}); + + assertTrue("Fehler: Element 118 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(118)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 905, 135, 391, 452}); + + dieListe.anhaengen(508); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 905, 135, 391, 452, 508}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{118, 135, 391, 452, 508}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 391, 452, 508}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + dieListe.einfuegenBei(3, 68); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 391, 452, 68, 508}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{108}); + + dieListe.einfuegenBei(1, 989); + Tester.pruefeListenInhalt(dieListe, new int[]{108, 989}); + + assertTrue("Fehler: Element 989 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(989)); + dieListe.anhaengen(912); + Tester.pruefeListenInhalt(dieListe, new int[]{108, 989, 912}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(81); + Tester.pruefeListenInhalt(dieListe, new int[]{81}); + + dieListe.anhaengen(928); + Tester.pruefeListenInhalt(dieListe, new int[]{81, 928}); + + assertFalse("Fehler: Element 400 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(400)); + assertFalse("Fehler: Element 600 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(600)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{81}); + + dieListe.einfuegenBei(0, 700); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81}); + + dieListe.anhaengen(991); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81, 991}); + + assertFalse("Fehler: Element 407 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(407)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81}); + + dieListe.einfuegenBei(2, 292); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 81, 292}); + + dieListe.einfuegenBei(1, 379); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292}); + + dieListe.anhaengen(634); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 634}); + + dieListe.einfuegenBei(5, 319); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 634, 319}); + + assertTrue("Fehler: Element 700 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(700)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 319}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292}); + + dieListe.anhaengen(4); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4}); + + dieListe.anhaengen(274); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4, 274}); + + assertTrue("Fehler: Element 274 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(274)); + assertTrue("Fehler: Element 4 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(4)); + dieListe.anhaengen(822); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 81, 292, 4, 274, 822}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 379, 292, 4, 274, 822}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 4, 274, 822}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 4, 822}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292, 822}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{700, 292}); + + assertFalse("Fehler: Element 367 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(367)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{292}); + + dieListe.einfuegenBei(1, 203); + Tester.pruefeListenInhalt(dieListe, new int[]{292, 203}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); + dieListe.einfuegenBei(0, 366); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 292, 203}); + + dieListe.anhaengen(400); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 292, 203, 400}); + + assertTrue("Fehler: Element 400 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(400)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 203, 400}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 400}); + + dieListe.einfuegenBei(0, 963); + Tester.pruefeListenInhalt(dieListe, new int[]{963, 366, 400}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{366, 400}); + + dieListe.einfuegenBei(0, 778); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 400}); + + dieListe.einfuegenBei(3, 813); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 400, 813}); + + dieListe.anhaengen(881); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 400, 813, 881}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 813, 881}); + + dieListe.anhaengen(172); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 366, 813, 881, 172}); + + dieListe.einfuegenBei(1, 509); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 366, 813, 881, 172}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.einfuegenBei(6, 355); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 366, 813, 881, 172, 355}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 813, 881, 172, 355}); + + dieListe.anhaengen(247); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 813, 881, 172, 355, 247}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 509, 881, 172, 355, 247}); + + dieListe.einfuegenBei(1, 543); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 881, 172, 355, 247}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 172, 355, 247}); + + dieListe.einfuegenBei(6, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{778, 543, 509, 172, 355, 247, 59}); + + assertFalse("Fehler: Element 705 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(705)); + dieListe.einfuegenBei(0, 334); + Tester.pruefeListenInhalt(dieListe, new int[]{334, 778, 543, 509, 172, 355, 247, 59}); + + dieListe.einfuegenBei(0, 137); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 509, 172, 355, 247, 59}); + + dieListe.einfuegenBei(8, 339); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 509, 172, 355, 247, 339, 59}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 172, 355, 247, 339, 59}); + + dieListe.einfuegenBei(4, 754); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59}); + + dieListe.anhaengen(61); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59, 61}); + + dieListe.anhaengen(447); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 247, 339, 59, 61, 447}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 543, 754, 172, 355, 339, 59, 61, 447}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 778, 754, 172, 355, 339, 59, 61, 447}); + + assertFalse("Fehler: Element 138 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(138)); + dieListe.einfuegenBei(2, 18); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 61, 447}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 447}); + + dieListe.einfuegenBei(7, 355); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 355, 339, 59, 447}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 172, 355, 339, 59, 447}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 334, 18, 778, 754, 355, 339, 59, 447}); + + dieListe.einfuegenBei(1, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 778, 754, 355, 339, 59, 447}); + + dieListe.einfuegenBei(4, 343); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 447}); + + dieListe.einfuegenBei(10, 268); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 268, 447}); + + dieListe.einfuegenBei(10, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447}); + + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447, 968}); + + dieListe.anhaengen(186); + Tester.pruefeListenInhalt(dieListe, new int[]{137, 666, 334, 18, 343, 778, 754, 355, 339, 59, 539, 268, 447, 968, 186}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest8.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest8.java new file mode 100644 index 0000000..d8dc5a3 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest8.java @@ -0,0 +1,2821 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest8. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest8 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(801); + Tester.pruefeListenInhalt(dieListe, new int[]{801}); + + dieListe.einfuegenBei(0, 658); + Tester.pruefeListenInhalt(dieListe, new int[]{658, 801}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{658, 801, 896}); + + dieListe.einfuegenBei(0, 618); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 658, 801, 896}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 658, 801}); + + assertTrue("Fehler: Element 658 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(658)); + dieListe.einfuegenBei(1, 715); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658, 801}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658}); + + dieListe.anhaengen(888); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 715, 658, 888}); + + dieListe.einfuegenBei(0, 224); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 658, 888}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 888}); + + dieListe.einfuegenBei(3, 550); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 550, 888}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 618, 715, 550}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{224, 715, 550}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{715, 550}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{715}); + + dieListe.einfuegenBei(0, 109); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715}); + + dieListe.anhaengen(687); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687}); + + dieListe.anhaengen(939); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967}); + + dieListe.anhaengen(40); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40}); + + assertFalse("Fehler: Element 879 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(879)); + dieListe.einfuegenBei(6, 55); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40, 55}); + + dieListe.anhaengen(80); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 967, 40, 55, 80}); + + assertTrue("Fehler: Element 939 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(939)); + dieListe.einfuegenBei(4, 357); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 357, 967, 40, 55, 80}); + + dieListe.anhaengen(245); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 939, 357, 967, 40, 55, 80, 245}); + + assertFalse("Fehler: Element 311 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(311)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 55, 80, 245}); + + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 55, 80, 245, 395}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 80, 245, 395}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 967, 40, 80, 245, 395, 437}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 437}); + + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 437, 494}); + + assertFalse("Fehler: Element 762 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(762)); + dieListe.einfuegenBei(8, 282); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 282, 437, 494}); + + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertFalse("Fehler: Element 855 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(855)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 282, 437}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.einfuegenBei(8, 123); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437}); + + dieListe.anhaengen(82); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82, 437}); + + dieListe.anhaengen(77); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 245, 395, 123, 282, 437, 82, 437, 77}); + + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + dieListe.einfuegenBei(6, 155); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77}); + + dieListe.anhaengen(570); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 687, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77, 570}); + + assertFalse("Fehler: Element 456 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(456)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 82, 437, 77, 570}); + + assertFalse("Fehler: Element 379 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(379)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + dieListe.einfuegenBei(11, 585); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 82, 437, 77, 570}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 82, 437, 77}); + + assertFalse("Fehler: Element 560 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(560)); + dieListe.einfuegenBei(12, 53); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.einfuegenBei(0, 512); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + assertTrue("Fehler: Element 715 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(715)); + dieListe.einfuegenBei(1, 142); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 142, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 155, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77}); + + dieListe.anhaengen(877); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877}); + + dieListe.anhaengen(853); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 245, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853}); + + assertTrue("Fehler: Element 437 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(437)); + dieListe.anhaengen(797); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 357, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853, 797}); + + assertTrue("Fehler: Element 877 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(877)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 77, 877, 853, 797}); + + assertTrue("Fehler: Element 40 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(40)); + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797}); + + dieListe.anhaengen(405); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405}); + + dieListe.einfuegenBei(3, 454); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405}); + + dieListe.anhaengen(642); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 395, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642}); + + dieListe.anhaengen(438); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 853, 797, 405, 642, 438}); + + dieListe.entferneBei(14); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 405, 642, 438}); + + assertTrue("Fehler: Element 282 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(282)); + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 405, 642}); + + dieListe.einfuegenBei(15, 425); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 282, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642}); + + assertFalse("Fehler: Element 61 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(61)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 80, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 642}); + + dieListe.einfuegenBei(15, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22}); + + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22, 25}); + + assertFalse("Fehler: Element 752 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(752)); + assertTrue("Fehler: Element 405 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(405)); + dieListe.anhaengen(591); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 437, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + assertFalse("Fehler: Element 161 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(161)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{512, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + dieListe.einfuegenBei(0, 181); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591}); + + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145}); + + dieListe.einfuegenBei(6, 117); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 117, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145}); + + dieListe.einfuegenBei(6, 495); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 495, 117, 437, 585, 53, 82, 877, 797, 425, 405, 75, 642, 22, 25, 591, 145}); + + dieListe.einfuegenBei(15, 918); + Tester.pruefeListenInhalt(dieListe, new int[]{181, 109, 715, 454, 40, 123, 495, 117, 437, 585, 53, 82, 877, 797, 425, 918, 405, 75, 642, 22, 25, 591, 145}); + + assertFalse("Fehler: Element 39 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(39)); + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{449}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(136); + Tester.pruefeListenInhalt(dieListe, new int[]{136}); + + assertTrue("Fehler: Element 136 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(136)); + dieListe.einfuegenBei(0, 783); + Tester.pruefeListenInhalt(dieListe, new int[]{783, 136}); + + dieListe.anhaengen(630); + Tester.pruefeListenInhalt(dieListe, new int[]{783, 136, 630}); + + assertTrue("Fehler: Element 783 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(783)); + dieListe.einfuegenBei(2, 107); + Tester.pruefeListenInhalt(dieListe, new int[]{783, 136, 107, 630}); + + assertFalse("Fehler: Element 697 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(697)); + dieListe.einfuegenBei(0, 986); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 783, 136, 107, 630}); + + dieListe.anhaengen(441); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 783, 136, 107, 630, 441}); + + dieListe.einfuegenBei(1, 403); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 136, 107, 630, 441}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 136, 107, 441}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 783, 107, 441}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 107, 441}); + + dieListe.anhaengen(758); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 403, 107, 441, 758}); + + assertTrue("Fehler: Element 986 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(986)); + dieListe.einfuegenBei(1, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758}); + + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758, 19}); + + dieListe.anhaengen(465); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 107, 441, 758, 19, 465}); + + dieListe.einfuegenBei(3, 602); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 602, 107, 441, 758, 19, 465}); + + assertFalse("Fehler: Element 230 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(230)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{986, 70, 403, 602, 107, 441, 758, 465}); + + assertTrue("Fehler: Element 758 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(758)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 623); + Tester.pruefeListenInhalt(dieListe, new int[]{623}); + + assertFalse("Fehler: Element 98 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(98)); + dieListe.einfuegenBei(0, 96); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 623}); + + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.einfuegenBei(2, 146); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 623, 146}); + + dieListe.einfuegenBei(3, 268); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 623, 146, 268}); + + dieListe.einfuegenBei(1, 195); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 623, 146, 268}); + + assertFalse("Fehler: Element 619 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(619)); + assertFalse("Fehler: Element 835 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(835)); + assertTrue("Fehler: Element 96 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(96)); + assertTrue("Fehler: Element 195 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(195)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 146, 268}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 146}); + + dieListe.einfuegenBei(2, 115); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 195, 115, 146}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146}); + + dieListe.einfuegenBei(3, 850); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146, 850}); + + assertFalse("Fehler: Element 944 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(944)); + dieListe.einfuegenBei(4, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 115, 146, 850, 532}); + + dieListe.einfuegenBei(1, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532}); + + dieListe.anhaengen(6); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532, 6}); + + dieListe.anhaengen(631); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 115, 146, 850, 532, 6, 631}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 631}); + + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 631, 257}); + + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 850, 532, 6, 257}); + + assertFalse("Fehler: Element 833 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(833)); + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.einfuegenBei(3, 655); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257}); + + dieListe.anhaengen(358); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257, 358}); + + assertFalse("Fehler: Element 249 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(249)); + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{96, 95, 146, 655, 850, 532, 6, 257, 358, 154}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 584); + Tester.pruefeListenInhalt(dieListe, new int[]{584}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{557}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 520); + Tester.pruefeListenInhalt(dieListe, new int[]{520}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 26); + Tester.pruefeListenInhalt(dieListe, new int[]{26}); + + assertTrue("Fehler: Element 26 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(26)); + dieListe.einfuegenBei(0, 791); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26}); + + dieListe.einfuegenBei(2, 198); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198}); + + assertFalse("Fehler: Element 29 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(29)); + assertFalse("Fehler: Element 876 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(876)); + dieListe.einfuegenBei(1, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 78, 26, 198}); + + dieListe.anhaengen(925); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 78, 26, 198, 925}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 925}); + + dieListe.anhaengen(568); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 925, 568}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 26, 198, 568}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568}); + + dieListe.einfuegenBei(3, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568, 436}); + + dieListe.anhaengen(137); + Tester.pruefeListenInhalt(dieListe, new int[]{791, 198, 568, 436, 137}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 623); + Tester.pruefeListenInhalt(dieListe, new int[]{623}); + + dieListe.anhaengen(731); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 731}); + + dieListe.einfuegenBei(1, 808); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731, 329}); + + dieListe.anhaengen(33); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 731, 329, 33}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.anhaengen(620); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620}); + + dieListe.einfuegenBei(0, 425); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 623, 808, 329, 33, 620}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{425, 623, 808, 329, 33, 620, 718}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 718}); + + dieListe.anhaengen(951); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 718, 951}); + + dieListe.einfuegenBei(5, 928); + Tester.pruefeListenInhalt(dieListe, new int[]{623, 808, 329, 33, 620, 928, 718, 951}); + + assertFalse("Fehler: Element 390 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(390)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{808, 329, 33, 620, 928, 718, 951}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 620, 928, 718, 951}); + + dieListe.einfuegenBei(2, 897); + Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 897, 620, 928, 718, 951}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{329, 33, 897, 620, 718, 951}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{414}); + + dieListe.anhaengen(521); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521}); + + dieListe.anhaengen(63); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63}); + + assertFalse("Fehler: Element 265 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(265)); + dieListe.einfuegenBei(1, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63}); + + dieListe.anhaengen(724); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724}); + + assertFalse("Fehler: Element 316 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(316)); + dieListe.einfuegenBei(5, 890); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724, 890}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 736, 521, 63, 724}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63, 724}); + + assertTrue("Fehler: Element 724 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(724)); + assertFalse("Fehler: Element 93 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(93)); + dieListe.anhaengen(157); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 521, 63, 724, 157}); + + assertTrue("Fehler: Element 521 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(521)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{414, 63, 724, 157}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 724, 157}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 157}); + + dieListe.einfuegenBei(0, 533); + Tester.pruefeListenInhalt(dieListe, new int[]{533, 63, 157}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 157}); + + dieListe.einfuegenBei(2, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{63, 157, 647}); + + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647}); + + dieListe.anhaengen(386); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647, 386}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647}); + + dieListe.einfuegenBei(2, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{157, 647, 247}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 629); + Tester.pruefeListenInhalt(dieListe, new int[]{629}); + + dieListe.einfuegenBei(1, 5); + Tester.pruefeListenInhalt(dieListe, new int[]{629, 5}); + + dieListe.einfuegenBei(2, 290); + Tester.pruefeListenInhalt(dieListe, new int[]{629, 5, 290}); + + dieListe.einfuegenBei(1, 167); + Tester.pruefeListenInhalt(dieListe, new int[]{629, 167, 5, 290}); + + assertTrue("Fehler: Element 629 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(629)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{167, 5, 290}); + + assertTrue("Fehler: Element 167 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(167)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{167, 290}); + + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + assertFalse("Fehler: Element 762 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(762)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{290}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{748}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{967}); + + assertTrue("Fehler: Element 967 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(967)); + dieListe.einfuegenBei(1, 797); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797}); + + dieListe.anhaengen(445); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + assertFalse("Fehler: Element 708 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(708)); + dieListe.anhaengen(328); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445, 328}); + + dieListe.anhaengen(434); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 445, 328, 434}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 434}); + + dieListe.einfuegenBei(3, 183); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 434}); + + assertTrue("Fehler: Element 434 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(434)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183}); + + dieListe.einfuegenBei(2, 154); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 154, 328, 183}); + + dieListe.einfuegenBei(1, 361); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 361, 797, 154, 328, 183}); + + dieListe.anhaengen(171); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 361, 797, 154, 328, 183, 171}); + + dieListe.einfuegenBei(1, 153); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 154, 328, 183, 171}); + + assertFalse("Fehler: Element 966 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(966)); + assertTrue("Fehler: Element 967 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(967)); + dieListe.einfuegenBei(0, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{842, 967, 153, 361, 797, 154, 328, 183, 171}); + + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{842, 967, 153, 361, 797, 154, 328, 183, 171, 86}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 154, 328, 183, 171, 86}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 86}); + + dieListe.anhaengen(745); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 86, 745}); + + assertFalse("Fehler: Element 283 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(283)); + dieListe.einfuegenBei(7, 945); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 361, 797, 328, 183, 171, 945, 86, 745}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 153, 797, 328, 183, 171, 945, 86, 745}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 171, 945, 86, 745}); + + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertTrue("Fehler: Element 171 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(171)); + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + assertTrue("Fehler: Element 745 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(745)); + dieListe.einfuegenBei(5, 926); + Tester.pruefeListenInhalt(dieListe, new int[]{967, 797, 328, 183, 171, 926, 945, 86, 745}); + + dieListe.einfuegenBei(0, 374); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 797, 328, 183, 171, 926, 945, 86, 745}); + + dieListe.einfuegenBei(7, 68); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 797, 328, 183, 171, 926, 68, 945, 86, 745}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 328, 183, 171, 926, 68, 945, 86, 745}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 183, 171, 926, 68, 945, 86, 745}); + + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); + assertTrue("Fehler: Element 86 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(86)); + assertFalse("Fehler: Element 378 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(378)); + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 967, 183, 171, 926, 68, 945, 86, 745, 71}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 86, 745, 71}); + + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 86, 745, 71, 615}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 68, 945, 745, 71, 615}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 171, 926, 945, 745, 71, 615}); + + dieListe.einfuegenBei(2, 529); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615}); + + assertFalse("Fehler: Element 617 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(617)); + assertTrue("Fehler: Element 926 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(926)); + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335}); + + assertTrue("Fehler: Element 945 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(945)); + dieListe.anhaengen(857); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857}); + + dieListe.anhaengen(784); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784}); + + dieListe.anhaengen(248); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784, 248}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784}); + + assertTrue("Fehler: Element 857 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(857)); + dieListe.anhaengen(717); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 857, 784, 717}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 183, 529, 171, 926, 945, 745, 71, 615, 335, 784, 717}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{374, 529, 171, 926, 945, 745, 71, 615, 335, 784, 717}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{481}); + + dieListe.einfuegenBei(0, 263); + Tester.pruefeListenInhalt(dieListe, new int[]{263, 481}); + + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 263, 481}); + + dieListe.einfuegenBei(0, 424); + Tester.pruefeListenInhalt(dieListe, new int[]{424, 85, 263, 481}); + + dieListe.einfuegenBei(0, 565); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 85, 263, 481}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481}); + + dieListe.einfuegenBei(4, 272); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481, 272}); + + dieListe.anhaengen(3); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 481, 272, 3}); + + dieListe.einfuegenBei(3, 803); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 263, 803, 481, 272, 3}); + + dieListe.einfuegenBei(2, 980); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 263, 803, 481, 272, 3}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 803, 481, 272, 3}); + + dieListe.anhaengen(658); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 424, 980, 803, 481, 272, 3, 658}); + + dieListe.einfuegenBei(0, 893); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 980, 803, 481, 272, 3, 658}); + + dieListe.anhaengen(572); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 980, 803, 481, 272, 3, 658, 572}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 424, 803, 481, 272, 3, 658, 572}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 803, 481, 272, 3, 658, 572}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 565, 803, 481, 272, 3, 658}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{388}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(204); + Tester.pruefeListenInhalt(dieListe, new int[]{204}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935}); + + assertFalse("Fehler: Element 524 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(524)); + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19}); + + dieListe.anhaengen(458); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19, 458}); + + dieListe.anhaengen(379); + Tester.pruefeListenInhalt(dieListe, new int[]{204, 935, 19, 458, 379}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{935, 19, 458, 379}); + + assertTrue("Fehler: Element 935 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(935)); + dieListe.einfuegenBei(0, 127); + Tester.pruefeListenInhalt(dieListe, new int[]{127, 935, 19, 458, 379}); + + assertTrue("Fehler: Element 935 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(935)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 828); + Tester.pruefeListenInhalt(dieListe, new int[]{828}); + + dieListe.einfuegenBei(1, 714); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714}); + + dieListe.anhaengen(863); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 863}); + + dieListe.einfuegenBei(2, 333); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 333, 863}); + + dieListe.einfuegenBei(0, 203); + Tester.pruefeListenInhalt(dieListe, new int[]{203, 828, 714, 333, 863}); + + dieListe.anhaengen(266); + Tester.pruefeListenInhalt(dieListe, new int[]{203, 828, 714, 333, 863, 266}); + + assertTrue("Fehler: Element 203 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(203)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 714, 333, 863, 266}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 333, 863, 266}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 333, 266}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{828, 333}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 876); + Tester.pruefeListenInhalt(dieListe, new int[]{876}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(484); + Tester.pruefeListenInhalt(dieListe, new int[]{484}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 24); + Tester.pruefeListenInhalt(dieListe, new int[]{24}); + + dieListe.einfuegenBei(1, 810); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810}); + + assertFalse("Fehler: Element 303 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(303)); + dieListe.einfuegenBei(1, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810}); + + assertFalse("Fehler: Element 727 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(727)); + dieListe.anhaengen(693); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693}); + + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693, 340}); + + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 723, 810, 693, 340, 86}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 86}); + + dieListe.anhaengen(796); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 86, 796}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 796}); + + assertTrue("Fehler: Element 340 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(340)); + dieListe.einfuegenBei(5, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 796, 218}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 693, 340, 218}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 810, 340, 218}); + + assertFalse("Fehler: Element 732 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(732)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{24, 340, 218}); + + dieListe.einfuegenBei(0, 395); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 24, 340, 218}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{395, 24, 218}); + + dieListe.einfuegenBei(0, 279); + Tester.pruefeListenInhalt(dieListe, new int[]{279, 395, 24, 218}); + + dieListe.einfuegenBei(0, 604); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 279, 395, 24, 218}); + + dieListe.einfuegenBei(4, 798); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 279, 395, 24, 798, 218}); + + assertFalse("Fehler: Element 836 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(836)); + dieListe.einfuegenBei(0, 85); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 279, 395, 24, 798, 218}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798, 218}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 798, 217}); + + assertFalse("Fehler: Element 597 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(597)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 24, 217}); + + assertTrue("Fehler: Element 85 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(85)); + assertFalse("Fehler: Element 16 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(16)); + dieListe.einfuegenBei(3, 553); + Tester.pruefeListenInhalt(dieListe, new int[]{85, 604, 395, 553, 24, 217}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 553, 24, 217}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217}); + + dieListe.anhaengen(429); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429}); + + dieListe.anhaengen(956); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956}); + + dieListe.anhaengen(334); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956, 334}); + + assertTrue("Fehler: Element 334 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(334)); + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 956, 334, 461}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 217, 429, 334, 461}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461}); + + dieListe.anhaengen(635); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461, 635}); + + dieListe.anhaengen(718); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 429, 334, 461, 635, 718}); + + assertTrue("Fehler: Element 461 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(461)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 334, 461, 635, 718}); + + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 395, 24, 334, 461, 635, 718, 651}); + + dieListe.einfuegenBei(1, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 651}); + + dieListe.anhaengen(108); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 651, 108}); + + dieListe.einfuegenBei(8, 568); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 635, 718, 568, 651, 108}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 718, 568, 651, 108}); + + dieListe.anhaengen(563); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 718, 568, 651, 108, 563}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 482, 395, 24, 334, 461, 568, 651, 108, 563}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{665}); + + dieListe.anhaengen(262); + Tester.pruefeListenInhalt(dieListe, new int[]{665, 262}); + + dieListe.einfuegenBei(0, 41); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 262}); + + dieListe.einfuegenBei(2, 78); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 78, 262}); + + dieListe.einfuegenBei(0, 647); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262}); + + assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262)); + dieListe.anhaengen(340); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262, 340}); + + dieListe.einfuegenBei(5, 648); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 78, 262, 648, 340}); + + dieListe.einfuegenBei(3, 421); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 78, 262, 648, 340}); + + dieListe.einfuegenBei(4, 829); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 829, 78, 262, 648, 340}); + + dieListe.einfuegenBei(5, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{647, 41, 665, 421, 829, 757, 78, 262, 648, 340}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 421, 829, 757, 78, 262, 648, 340}); + + assertTrue("Fehler: Element 829 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(829)); + dieListe.anhaengen(870); + Tester.pruefeListenInhalt(dieListe, new int[]{41, 665, 421, 829, 757, 78, 262, 648, 340, 870}); + + dieListe.einfuegenBei(0, 720); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 262, 648, 340, 870}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870}); + + dieListe.einfuegenBei(10, 995); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995}); + + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736}); + + assertTrue("Fehler: Element 648 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(648)); + dieListe.anhaengen(119); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119}); + + assertTrue("Fehler: Element 41 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(41)); + dieListe.anhaengen(291); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 291}); + + assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394)); + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 291, 196}); + + assertTrue("Fehler: Element 119 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(119)); + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 196}); + + dieListe.anhaengen(135); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.einfuegenBei(7, 712); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.einfuegenBei(12, 137); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 137, 736, 119, 196, 135}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 41, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 421, 829, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.einfuegenBei(4, 867); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 421, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135}); + + dieListe.anhaengen(335); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.einfuegenBei(5, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 757, 78, 712, 648, 340, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 757, 78, 712, 648, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 870, 995, 736, 119, 196, 135, 335}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 712, 648, 870, 995, 736, 119, 135, 335}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335}); + + dieListe.einfuegenBei(13, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42}); + + dieListe.anhaengen(461); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 665, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42, 461}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 870, 995, 736, 119, 135, 335, 42, 461}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + dieListe.anhaengen(408); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 829, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408}); + + dieListe.einfuegenBei(3, 984); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 648, 995, 736, 119, 135, 335, 42, 461, 408}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 736, 119, 135, 335, 42, 461, 408}); + + assertFalse("Fehler: Element 449 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(449)); + assertTrue("Fehler: Element 984 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(984)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 135, 335, 42, 461, 408}); + + assertFalse("Fehler: Element 239 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(239)); + dieListe.einfuegenBei(7, 790); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 790, 135, 335, 42, 461, 408}); + + assertFalse("Fehler: Element 131 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(131)); + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 867, 757, 984, 78, 995, 119, 790, 135, 335, 42, 461}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 896); + Tester.pruefeListenInhalt(dieListe, new int[]{896}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{146}); + + assertTrue("Fehler: Element 146 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(380); + Tester.pruefeListenInhalt(dieListe, new int[]{146, 380}); + + assertFalse("Fehler: Element 852 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(852)); + dieListe.einfuegenBei(0, 510); + Tester.pruefeListenInhalt(dieListe, new int[]{510, 146, 380}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{510, 146}); + + dieListe.einfuegenBei(2, 535); + Tester.pruefeListenInhalt(dieListe, new int[]{510, 146, 535}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 749); + Tester.pruefeListenInhalt(dieListe, new int[]{749}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(826); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{826, 923}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{826}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{702}); + + dieListe.einfuegenBei(0, 754); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702}); + + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539}); + + dieListe.einfuegenBei(0, 638); + Tester.pruefeListenInhalt(dieListe, new int[]{638, 754, 702, 539}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539}); + + assertTrue("Fehler: Element 702 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(702)); + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 411}); + + dieListe.einfuegenBei(3, 911); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 911, 411}); + + dieListe.einfuegenBei(5, 138); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 702, 539, 911, 411, 138}); + + dieListe.einfuegenBei(1, 485); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 485, 702, 539, 911, 411, 138}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(869); + Tester.pruefeListenInhalt(dieListe, new int[]{869}); + + dieListe.einfuegenBei(0, 281); + Tester.pruefeListenInhalt(dieListe, new int[]{281, 869}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{869}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 436); + Tester.pruefeListenInhalt(dieListe, new int[]{436}); + + assertTrue("Fehler: Element 436 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(436)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 938); + Tester.pruefeListenInhalt(dieListe, new int[]{938}); + + dieListe.einfuegenBei(1, 397); + Tester.pruefeListenInhalt(dieListe, new int[]{938, 397}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{397}); + + assertFalse("Fehler: Element 274 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(274)); + dieListe.einfuegenBei(0, 502); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 397}); + + dieListe.anhaengen(315); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 397, 315}); + + assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140)); + dieListe.anhaengen(383); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 397, 315, 383}); + + assertTrue("Fehler: Element 315 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(315)); + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(429); + Tester.pruefeListenInhalt(dieListe, new int[]{429}); + + dieListe.einfuegenBei(1, 324); + Tester.pruefeListenInhalt(dieListe, new int[]{429, 324}); + + assertFalse("Fehler: Element 24 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(24)); + dieListe.einfuegenBei(2, 840); + Tester.pruefeListenInhalt(dieListe, new int[]{429, 324, 840}); + + dieListe.einfuegenBei(0, 173); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840}); + + assertTrue("Fehler: Element 840 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(840)); + assertFalse("Fehler: Element 984 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(984)); + assertFalse("Fehler: Element 641 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(641)); + assertTrue("Fehler: Element 324 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(324)); + dieListe.einfuegenBei(4, 457); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840, 457}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840}); + + dieListe.einfuegenBei(4, 95); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 324, 840, 95}); + + assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95}); + + assertFalse("Fehler: Element 669 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(669)); + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95, 708}); + + dieListe.einfuegenBei(4, 707); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 95, 707, 708}); + + dieListe.einfuegenBei(3, 33); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95, 707, 708}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95, 708}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 840, 33, 95}); + + dieListe.einfuegenBei(2, 128); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 429, 128, 840, 33, 95}); + + dieListe.einfuegenBei(1, 920); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 429, 128, 840, 33, 95}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95, 154}); + + dieListe.anhaengen(640); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 95, 154, 640}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 154, 640}); + + assertTrue("Fehler: Element 128 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(128)); + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + assertTrue("Fehler: Element 920 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(920)); + dieListe.anhaengen(738); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 33, 154, 640, 738}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738}); + + dieListe.einfuegenBei(7, 637); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637}); + + dieListe.einfuegenBei(8, 532); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637, 532}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 637}); + + assertFalse("Fehler: Element 511 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(511)); + dieListe.einfuegenBei(7, 742); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 154, 640, 738, 742, 637}); + + dieListe.einfuegenBei(4, 500); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637}); + + dieListe.anhaengen(392); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637, 392}); + + dieListe.anhaengen(550); + Tester.pruefeListenInhalt(dieListe, new int[]{173, 920, 128, 840, 500, 154, 640, 738, 742, 637, 392, 550}); + + assertFalse("Fehler: Element 847 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(847)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(426); + Tester.pruefeListenInhalt(dieListe, new int[]{426}); + + dieListe.einfuegenBei(1, 255); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 255}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{426}); + + dieListe.anhaengen(149); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 387}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149}); + + dieListe.einfuegenBei(2, 716); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 716}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 446}); + + dieListe.einfuegenBei(0, 349); + Tester.pruefeListenInhalt(dieListe, new int[]{349, 426, 149, 446}); + + dieListe.einfuegenBei(3, 271); + Tester.pruefeListenInhalt(dieListe, new int[]{349, 426, 149, 271, 446}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{426, 149, 271, 446}); + + dieListe.einfuegenBei(0, 838); + Tester.pruefeListenInhalt(dieListe, new int[]{838, 426, 149, 271, 446}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{838, 149, 271, 446}); + + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 271, 446}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 271}); + + dieListe.einfuegenBei(1, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 271}); + + dieListe.einfuegenBei(2, 921); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 271}); + + dieListe.einfuegenBei(1, 488); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 488, 496, 921, 271}); + + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 488, 496, 921, 271, 871}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 271, 871}); + + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 496, 921, 871}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 921, 871}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 921, 871, 105}); + + dieListe.einfuegenBei(0, 588); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 149, 921, 871, 105}); + + dieListe.einfuegenBei(0, 733); + Tester.pruefeListenInhalt(dieListe, new int[]{733, 588, 149, 921, 871, 105}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 149, 921, 871, 105}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{588, 921, 871, 105}); + + dieListe.einfuegenBei(0, 971); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 921, 871, 105}); + + dieListe.einfuegenBei(2, 738); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 738, 921, 871, 105}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 588, 921, 871, 105}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{971, 921, 871, 105}); + + dieListe.einfuegenBei(0, 959); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 921, 871, 105}); + + assertTrue("Fehler: Element 921 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(921)); + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 105}); + + dieListe.einfuegenBei(3, 313); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 313, 105}); + + dieListe.einfuegenBei(3, 611); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 105}); + + dieListe.einfuegenBei(5, 970); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 970, 105}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 105}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313}); + + dieListe.anhaengen(628); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 628}); + + dieListe.einfuegenBei(0, 214); + Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313, 628}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313}); + + dieListe.anhaengen(860); + Tester.pruefeListenInhalt(dieListe, new int[]{214, 959, 971, 871, 611, 313, 860}); + + assertFalse("Fehler: Element 242 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(242)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 611, 313, 860}); + + dieListe.einfuegenBei(3, 508); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 971, 871, 508, 611, 313, 860}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 508, 611, 313, 860}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 508, 611, 313, 860, 446}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 860, 446}); + + dieListe.einfuegenBei(6, 546); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 860, 446, 546}); + + dieListe.einfuegenBei(4, 44); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546}); + + assertTrue("Fehler: Element 871 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(871)); + dieListe.anhaengen(120); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546, 120}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{959, 871, 611, 313, 44, 860, 446, 546, 120, 43}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(555); + Tester.pruefeListenInhalt(dieListe, new int[]{555}); + + dieListe.anhaengen(450); + Tester.pruefeListenInhalt(dieListe, new int[]{555, 450}); + + assertTrue("Fehler: Element 450 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(450)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{608}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(409); + Tester.pruefeListenInhalt(dieListe, new int[]{409}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{884}); + + dieListe.anhaengen(559); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559}); + + dieListe.anhaengen(329); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329}); + + dieListe.anhaengen(65); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329, 65}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329}); + + dieListe.einfuegenBei(2, 218); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 218, 329}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559, 329}); + + assertFalse("Fehler: Element 326 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(326)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{884, 559}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{559}); + + dieListe.einfuegenBei(0, 651); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 559}); + + assertTrue("Fehler: Element 651 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(651)); + dieListe.anhaengen(399); + Tester.pruefeListenInhalt(dieListe, new int[]{651, 559, 399}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{559, 399}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{757}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(105); + Tester.pruefeListenInhalt(dieListe, new int[]{105}); + + dieListe.einfuegenBei(0, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 105}); + + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 105, 121}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 105}); + + dieListe.einfuegenBei(1, 245); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 105}); + + dieListe.anhaengen(950); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 105, 950}); + + dieListe.anhaengen(161); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 105, 950, 161}); + + assertFalse("Fehler: Element 130 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(130)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 245, 950, 161}); + + dieListe.einfuegenBei(1, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{16, 562, 245, 950, 161}); + + dieListe.einfuegenBei(0, 352); + Tester.pruefeListenInhalt(dieListe, new int[]{352, 16, 562, 245, 950, 161}); + + assertTrue("Fehler: Element 16 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(16)); + assertFalse("Fehler: Element 466 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(466)); + assertTrue("Fehler: Element 245 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(245)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{77}); + + dieListe.anhaengen(312); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 312}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{77}); + + assertFalse("Fehler: Element 940 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(940)); + assertTrue("Fehler: Element 77 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(77)); + dieListe.einfuegenBei(1, 806); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 806}); + + dieListe.einfuegenBei(2, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{77, 806, 398}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398}); + + dieListe.anhaengen(285); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285}); + + dieListe.anhaengen(565); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 565}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285}); + + assertFalse("Fehler: Element 446 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(446)); + dieListe.anhaengen(297); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 297}); + + assertTrue("Fehler: Element 806 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(806)); + assertFalse("Fehler: Element 328 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(328)); + dieListe.anhaengen(171); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 285, 297, 171}); + + dieListe.einfuegenBei(0, 39); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 285, 297, 171}); + + dieListe.einfuegenBei(3, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 285, 297, 171}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171}); + + dieListe.anhaengen(675); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675}); + + assertFalse("Fehler: Element 301 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(301)); + dieListe.anhaengen(871); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 871}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675}); + + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351}); + + dieListe.einfuegenBei(9, 773); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351, 773}); + + dieListe.anhaengen(780); + Tester.pruefeListenInhalt(dieListe, new int[]{39, 806, 398, 77, 297, 171, 675, 474, 351, 773, 780}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 77, 297, 171, 675, 474, 351, 773, 780}); + + dieListe.einfuegenBei(2, 353); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780, 152}); + + assertFalse("Fehler: Element 824 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(824)); + dieListe.einfuegenBei(1, 133); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 351, 773, 780, 152}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 152}); + + dieListe.einfuegenBei(11, 82); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152}); + + dieListe.anhaengen(879); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152, 879}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 171, 675, 474, 773, 780, 82, 152, 879, 526}); + + dieListe.einfuegenBei(6, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526}); + + dieListe.anhaengen(586); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526, 586}); + + dieListe.anhaengen(919); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 474, 773, 780, 82, 152, 879, 526, 586, 919}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{806, 133, 398, 353, 77, 297, 174, 171, 675, 773, 780, 82, 152, 879, 526, 586, 919}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(602); + Tester.pruefeListenInhalt(dieListe, new int[]{602}); + + dieListe.einfuegenBei(0, 135); + Tester.pruefeListenInhalt(dieListe, new int[]{135, 602}); + + assertTrue("Fehler: Element 135 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(135)); + assertTrue("Fehler: Element 602 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(602)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{135}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 43); + Tester.pruefeListenInhalt(dieListe, new int[]{43}); + + assertTrue("Fehler: Element 43 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(43)); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{43, 440}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{440}); + + dieListe.einfuegenBei(1, 512); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 512}); + + dieListe.einfuegenBei(0, 483); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 440, 512}); + + assertFalse("Fehler: Element 68 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(68)); + dieListe.anhaengen(80); + Tester.pruefeListenInhalt(dieListe, new int[]{483, 440, 512, 80}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 512, 80}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{440, 512}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{512}); + + assertFalse("Fehler: Element 965 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(965)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(796); + Tester.pruefeListenInhalt(dieListe, new int[]{796}); + + dieListe.anhaengen(55); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 55}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{796}); + + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{796, 499}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{499}); + + assertTrue("Fehler: Element 499 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(499)); + dieListe.anhaengen(263); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263}); + + assertTrue("Fehler: Element 263 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(263)); + dieListe.anhaengen(539); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263, 539}); + + assertFalse("Fehler: Element 212 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(212)); + assertFalse("Fehler: Element 722 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(722)); + assertTrue("Fehler: Element 539 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(539)); + assertTrue("Fehler: Element 499 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(499)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263}); + + dieListe.anhaengen(368); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263, 368}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 263}); + + dieListe.einfuegenBei(1, 166); + Tester.pruefeListenInhalt(dieListe, new int[]{499, 166, 263}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{686}); + + dieListe.anhaengen(998); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998}); + + dieListe.einfuegenBei(0, 506); + Tester.pruefeListenInhalt(dieListe, new int[]{506, 686, 998}); + + dieListe.anhaengen(562); + Tester.pruefeListenInhalt(dieListe, new int[]{506, 686, 998, 562}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 562}); + + dieListe.anhaengen(57); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 562, 57}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 57}); + + assertFalse("Fehler: Element 22 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(22)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998}); + + dieListe.anhaengen(7); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 7}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998}); + + dieListe.anhaengen(994); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 994}); + + dieListe.anhaengen(699); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 994, 699}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 699}); + + dieListe.anhaengen(653); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 998, 699, 653}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 699, 653}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{686, 653}); + + assertFalse("Fehler: Element 740 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(740)); + dieListe.einfuegenBei(0, 307); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653}); + + dieListe.einfuegenBei(3, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633}); + + dieListe.anhaengen(163); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633, 163}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 633}); + + dieListe.einfuegenBei(3, 695); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 653, 695, 633}); + + assertTrue("Fehler: Element 653 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(653)); + assertFalse("Fehler: Element 358 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(358)); + dieListe.einfuegenBei(2, 985); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633}); + + dieListe.anhaengen(243); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243}); + + dieListe.anhaengen(912); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243, 912}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 653, 695, 633, 243, 912, 923}); + + dieListe.einfuegenBei(2, 527); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 653, 695, 633, 243, 912, 923}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 653, 695, 633, 243, 912, 923, 305}); + + dieListe.einfuegenBei(4, 364); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 527, 985, 364, 653, 695, 633, 243, 912, 923, 305}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305}); + + dieListe.anhaengen(110); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305, 110}); + + dieListe.anhaengen(896); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 912, 923, 305, 110, 896}); + + dieListe.einfuegenBei(8, 554); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896}); + + assertTrue("Fehler: Element 110 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(110)); + dieListe.anhaengen(615); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896, 615}); + + dieListe.einfuegenBei(14, 220); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 912, 923, 305, 110, 896, 220, 615}); + + dieListe.einfuegenBei(9, 537); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615}); + + dieListe.anhaengen(360); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360}); + + dieListe.einfuegenBei(18, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360, 447}); + + dieListe.anhaengen(326); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 360, 447, 326}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + dieListe.einfuegenBei(17, 17); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 305, 110, 896, 220, 615, 17, 360, 447, 326}); + + assertTrue("Fehler: Element 985 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(985)); + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326}); + + dieListe.anhaengen(593); + Tester.pruefeListenInhalt(dieListe, new int[]{307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593}); + + dieListe.einfuegenBei(0, 716); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593}); + + dieListe.anhaengen(679); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679}); + + dieListe.einfuegenBei(2, 243); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 243, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679}); + + dieListe.anhaengen(84); + Tester.pruefeListenInhalt(dieListe, new int[]{716, 307, 243, 686, 985, 364, 653, 695, 633, 243, 554, 537, 912, 923, 110, 896, 220, 615, 17, 360, 447, 326, 593, 679, 84}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 70); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + + dieListe.einfuegenBei(0, 364); + Tester.pruefeListenInhalt(dieListe, new int[]{364, 70}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + + dieListe.einfuegenBei(1, 998); + Tester.pruefeListenInhalt(dieListe, new int[]{70, 998}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{70}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(143); + Tester.pruefeListenInhalt(dieListe, new int[]{143}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 468); + Tester.pruefeListenInhalt(dieListe, new int[]{468}); + + dieListe.anhaengen(565); + Tester.pruefeListenInhalt(dieListe, new int[]{468, 565}); + + dieListe.einfuegenBei(2, 740); + Tester.pruefeListenInhalt(dieListe, new int[]{468, 565, 740}); + + assertTrue("Fehler: Element 740 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(740)); + assertFalse("Fehler: Element 951 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(951)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 740}); + + assertTrue("Fehler: Element 565 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(565)); + assertFalse("Fehler: Element 793 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(793)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{565}); + + dieListe.einfuegenBei(1, 477); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 477}); + + assertFalse("Fehler: Element 117 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(117)); + assertTrue("Fehler: Element 477 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(477)); + dieListe.einfuegenBei(2, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{565, 477, 666}); + + dieListe.einfuegenBei(0, 255); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 666}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477}); + + dieListe.anhaengen(965); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965}); + + dieListe.anhaengen(503); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965, 503}); + + assertTrue("Fehler: Element 255 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(255)); + assertTrue("Fehler: Element 965 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(965)); + dieListe.einfuegenBei(5, 614); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 965, 503, 614}); + + dieListe.einfuegenBei(3, 105); + Tester.pruefeListenInhalt(dieListe, new int[]{255, 565, 477, 105, 965, 503, 614}); + + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(435); + Tester.pruefeListenInhalt(dieListe, new int[]{435}); + + dieListe.einfuegenBei(1, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{435, 445}); + + assertFalse("Fehler: Element 996 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(996)); + dieListe.anhaengen(728); + Tester.pruefeListenInhalt(dieListe, new int[]{435, 445, 728}); + + dieListe.anhaengen(47); + Tester.pruefeListenInhalt(dieListe, new int[]{435, 445, 728, 47}); + + dieListe.einfuegenBei(0, 416); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47}); + + assertTrue("Fehler: Element 47 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(47)); + dieListe.anhaengen(191); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191}); + + dieListe.anhaengen(774); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191, 774}); + + dieListe.anhaengen(779); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 191, 774, 779}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779}); + + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838}); + + dieListe.anhaengen(223); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 223}); + + dieListe.anhaengen(96); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 223, 96}); + + dieListe.einfuegenBei(8, 159); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 159, 223, 96}); + + dieListe.anhaengen(815); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 838, 159, 223, 96, 815}); + + dieListe.einfuegenBei(7, 816); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 96, 815}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 815}); + + dieListe.anhaengen(305); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 779, 816, 838, 159, 223, 815, 305}); + + assertFalse("Fehler: Element 300 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(300)); + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 816, 838, 159, 223, 815, 305}); + + assertFalse("Fehler: Element 297 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(297)); + dieListe.anhaengen(932); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 47, 774, 816, 838, 159, 223, 815, 305, 932}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 816, 838, 159, 223, 815, 305, 932}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932}); + + dieListe.anhaengen(396); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396}); + + dieListe.anhaengen(351); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351, 267}); + + dieListe.anhaengen(722); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 932, 396, 351, 267, 722}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 305, 396, 351, 267, 722}); + + dieListe.einfuegenBei(9, 129); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722}); + + assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267)); + dieListe.anhaengen(743); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743}); + + dieListe.anhaengen(737); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 737}); + + dieListe.anhaengen(579); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 737, 579}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{416, 435, 445, 728, 774, 838, 159, 223, 815, 129, 305, 396, 351, 267, 722, 743, 579}); + + assertTrue("Fehler: Element 815 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(815)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(993); + Tester.pruefeListenInhalt(dieListe, new int[]{993}); + + assertFalse("Fehler: Element 89 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(89)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{604}); + + dieListe.anhaengen(228); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 228}); + + dieListe.anhaengen(344); + Tester.pruefeListenInhalt(dieListe, new int[]{604, 228, 344}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 344}); + + assertFalse("Fehler: Element 380 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(380)); + dieListe.anhaengen(146); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 344, 146}); + + dieListe.anhaengen(232); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 344, 146, 232}); + + dieListe.einfuegenBei(0, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 344, 146, 232}); + + dieListe.anhaengen(446); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 344, 146, 232, 446}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446, 646}); + + assertTrue("Fehler: Element 232 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(232)); + dieListe.anhaengen(226); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 146, 232, 446, 646, 226}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 228, 232, 446, 646, 226}); + + assertFalse("Fehler: Element 658 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(658)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 232, 446, 646, 226}); + + dieListe.anhaengen(670); + Tester.pruefeListenInhalt(dieListe, new int[]{228, 232, 446, 646, 226, 670}); + + dieListe.einfuegenBei(0, 294); + Tester.pruefeListenInhalt(dieListe, new int[]{294, 228, 232, 446, 646, 226, 670}); + + dieListe.einfuegenBei(0, 633); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 228, 232, 446, 646, 226, 670}); + + assertTrue("Fehler: Element 646 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(646)); + dieListe.einfuegenBei(3, 927); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 228, 927, 232, 446, 646, 226, 670}); + + assertFalse("Fehler: Element 815 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(815)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 927, 232, 446, 646, 226, 670}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{633, 294, 927, 232, 446, 226, 670}); + + dieListe.einfuegenBei(0, 389); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670}); + + dieListe.anhaengen(736); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 736}); + + assertTrue("Fehler: Element 389 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(389)); + dieListe.anhaengen(369); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 736, 369}); + + dieListe.einfuegenBei(8, 292); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369}); + + dieListe.einfuegenBei(1, 445); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369}); + + dieListe.anhaengen(554); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554}); + + dieListe.anhaengen(861); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554, 861}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{389, 445, 633, 294, 927, 232, 446, 226, 670, 292, 736, 369, 554}); + + assertFalse("Fehler: Element 91 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(91)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(153); + Tester.pruefeListenInhalt(dieListe, new int[]{153}); + + dieListe.anhaengen(145); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 145}); + + dieListe.anhaengen(309); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 145, 309}); + + dieListe.einfuegenBei(2, 106); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 145, 106, 309}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 106, 309}); + + assertFalse("Fehler: Element 140 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(140)); + assertTrue("Fehler: Element 309 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(309)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 106}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{153}); + + assertTrue("Fehler: Element 153 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(153)); + assertFalse("Fehler: Element 316 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(316)); + dieListe.einfuegenBei(1, 462); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 462}); + + dieListe.anhaengen(988); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 462, 988}); + + dieListe.einfuegenBei(1, 123); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 123, 462, 988}); + + dieListe.einfuegenBei(2, 704); + Tester.pruefeListenInhalt(dieListe, new int[]{153, 123, 704, 462, 988}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{736}); + + dieListe.anhaengen(100); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100}); + + dieListe.einfuegenBei(1, 169); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 169, 100}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100}); + + dieListe.anhaengen(540); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 540}); + + dieListe.anhaengen(486); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 540, 486}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{736, 100, 486}); + + dieListe.einfuegenBei(0, 866); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 736, 100, 486}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{482}); + + assertTrue("Fehler: Element 482 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(482)); + dieListe.anhaengen(651); + Tester.pruefeListenInhalt(dieListe, new int[]{482, 651}); + + assertFalse("Fehler: Element 459 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(459)); + assertTrue("Fehler: Element 482 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(482)); + dieListe.einfuegenBei(2, 842); + Tester.pruefeListenInhalt(dieListe, new int[]{482, 651, 842}); + + dieListe.einfuegenBei(0, 447); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 482, 651, 842}); + + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 482, 651, 842, 414}); + + dieListe.einfuegenBei(1, 310); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 651, 842, 414}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 651, 414}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 310, 482, 414}); + + assertFalse("Fehler: Element 415 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(415)); + assertTrue("Fehler: Element 310 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(310)); + dieListe.einfuegenBei(1, 33); + Tester.pruefeListenInhalt(dieListe, new int[]{447, 33, 310, 482, 414}); + + assertFalse("Fehler: Element 439 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(439)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{33, 310, 482, 414}); + + assertTrue("Fehler: Element 414 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(414)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{310, 482, 414}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{310, 414}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{414}); + + dieListe.einfuegenBei(0, 474); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 414}); + + assertFalse("Fehler: Element 644 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(644)); + dieListe.anhaengen(545); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 414, 545}); + + dieListe.anhaengen(510); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 414, 545, 510}); + + dieListe.einfuegenBei(0, 5); + Tester.pruefeListenInhalt(dieListe, new int[]{5, 474, 414, 545, 510}); + + dieListe.einfuegenBei(0, 745); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 474, 414, 545, 510}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 414, 545, 510}); + + dieListe.anhaengen(962); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 5, 414, 545, 510, 962}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 414, 545, 510, 962}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 510, 962}); + + dieListe.einfuegenBei(2, 700); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962}); + + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962, 440}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962}); + + dieListe.anhaengen(127); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 510, 962, 127}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 700, 962, 127}); + + dieListe.einfuegenBei(2, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 127}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 127, 217}); + + assertFalse("Fehler: Element 357 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(357)); + assertFalse("Fehler: Element 166 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(166)); + dieListe.einfuegenBei(5, 503); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217}); + + dieListe.anhaengen(22); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22}); + + dieListe.einfuegenBei(9, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435}); + + dieListe.anhaengen(85); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85}); + + dieListe.einfuegenBei(11, 870); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870}); + + assertFalse("Fehler: Element 49 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(49)); + assertFalse("Fehler: Element 425 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(425)); + dieListe.anhaengen(878); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870, 878}); + + dieListe.anhaengen(49); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 85, 870, 878, 49}); + + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + assertTrue("Fehler: Element 569 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(569)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 870, 878, 49}); + + assertFalse("Fehler: Element 493 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(493)); + dieListe.anhaengen(421); + Tester.pruefeListenInhalt(dieListe, new int[]{745, 545, 569, 700, 962, 503, 127, 217, 22, 435, 870, 878, 49, 421}); + + assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{659}); + + assertFalse("Fehler: Element 32 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(32)); + assertFalse("Fehler: Element 899 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(899)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(155); + Tester.pruefeListenInhalt(dieListe, new int[]{155}); + + dieListe.einfuegenBei(0, 205); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155}); + + assertFalse("Fehler: Element 994 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(994)); + assertFalse("Fehler: Element 146 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(146)); + dieListe.anhaengen(31); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31}); + + dieListe.anhaengen(557); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557}); + + assertFalse("Fehler: Element 980 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(980)); + assertTrue("Fehler: Element 205 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(205)); + assertFalse("Fehler: Element 438 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(438)); + dieListe.anhaengen(55); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557, 55}); + + dieListe.anhaengen(463); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 31, 557, 55, 463}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463}); + + assertFalse("Fehler: Element 750 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(750)); + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463, 709}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{205, 155, 557, 55, 463}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463}); + + dieListe.anhaengen(624); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463, 624}); + + assertFalse("Fehler: Element 842 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(842)); + dieListe.anhaengen(518); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 463, 624, 518}); + + assertTrue("Fehler: Element 463 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(463)); + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624, 518}); + + assertTrue("Fehler: Element 624 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(624)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624}); + + dieListe.anhaengen(217); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624, 217}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 557, 55, 624}); + + assertTrue("Fehler: Element 557 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(557)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{155, 55, 624}); + + dieListe.einfuegenBei(0, 363); + Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 55, 624}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 624}); + + dieListe.anhaengen(719); + Tester.pruefeListenInhalt(dieListe, new int[]{363, 155, 624, 719}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 73); + Tester.pruefeListenInhalt(dieListe, new int[]{73}); + + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{73, 957}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{957}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 854}); + + dieListe.einfuegenBei(2, 741); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 854, 741}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 741}); + + dieListe.einfuegenBei(0, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{598, 854, 741}); + + dieListe.einfuegenBei(0, 607); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 598, 854, 741}); + + dieListe.anhaengen(874); + Tester.pruefeListenInhalt(dieListe, new int[]{607, 598, 854, 741, 874}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest9.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest9.java new file mode 100644 index 0000000..6b3a2a8 --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/SubTest9.java @@ -0,0 +1,2773 @@ +package tests; + +import static org.junit.Assert.*; + +import liste.*; + +/** + * Die Test-Klasse SubTest9. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public class SubTest9 { + + + public static void test1Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{21}); + + dieListe.anhaengen(515); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 515}); + + dieListe.einfuegenBei(2, 49); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 515, 49}); + + assertFalse("Fehler: Element 949 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(949)); + assertTrue("Fehler: Element 21 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(21)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 49}); + + dieListe.anhaengen(476); + Tester.pruefeListenInhalt(dieListe, new int[]{21, 49, 476}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{49, 476}); + + dieListe.einfuegenBei(0, 927); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 49, 476}); + + dieListe.einfuegenBei(1, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 49, 476}); + + dieListe.einfuegenBei(2, 854); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 854, 49, 476}); + + dieListe.einfuegenBei(2, 624); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 624, 854, 49, 476}); + + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 132, 624, 854, 49, 476, 470}); + + dieListe.einfuegenBei(1, 558); + Tester.pruefeListenInhalt(dieListe, new int[]{927, 558, 132, 624, 854, 49, 476, 470}); + + assertFalse("Fehler: Element 578 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(578)); + dieListe.einfuegenBei(0, 213); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 624, 854, 49, 476, 470}); + + assertFalse("Fehler: Element 701 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(701)); + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 624, 854, 49, 476, 470, 257}); + + dieListe.einfuegenBei(4, 742); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 742, 624, 854, 49, 476, 470, 257}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{213, 927, 558, 132, 742, 624, 854, 49, 476, 257}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 984); + Tester.pruefeListenInhalt(dieListe, new int[]{984}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(720); + Tester.pruefeListenInhalt(dieListe, new int[]{720}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854}); + + dieListe.anhaengen(821); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 821}); + + dieListe.anhaengen(799); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 821, 799}); + + dieListe.einfuegenBei(3, 240); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 821, 240, 799}); + + dieListe.einfuegenBei(2, 490); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 490, 821, 240, 799}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 854, 490, 821, 799}); + + dieListe.einfuegenBei(0, 880); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799}); + + dieListe.anhaengen(975); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799, 975}); + + dieListe.anhaengen(458); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 854, 490, 821, 799, 975, 458}); + + assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854)); + assertTrue("Fehler: Element 799 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(799)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458}); + + dieListe.anhaengen(44); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458, 44}); + + dieListe.einfuegenBei(8, 748); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 458, 44, 748}); + + assertTrue("Fehler: Element 44 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(44)); + dieListe.einfuegenBei(6, 942); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 490, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.einfuegenBei(2, 844); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 844, 490, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.einfuegenBei(4, 89); + Tester.pruefeListenInhalt(dieListe, new int[]{880, 720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748}); + + dieListe.anhaengen(907); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 821, 799, 975, 942, 458, 44, 748, 907}); + + dieListe.einfuegenBei(4, 510); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 748, 907}); + + dieListe.anhaengen(496); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 748, 907, 496}); + + assertTrue("Fehler: Element 844 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(844)); + dieListe.einfuegenBei(11, 780); + Tester.pruefeListenInhalt(dieListe, new int[]{720, 844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496}); + + assertTrue("Fehler: Element 496 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(496)); + dieListe.anhaengen(142); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + + dieListe.einfuegenBei(5, 374); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + + dieListe.einfuegenBei(2, 887); + Tester.pruefeListenInhalt(dieListe, new int[]{844, 490, 887, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + + assertFalse("Fehler: Element 704 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(704)); + dieListe.einfuegenBei(0, 534); + Tester.pruefeListenInhalt(dieListe, new int[]{534, 844, 490, 887, 89, 510, 821, 374, 799, 975, 942, 458, 44, 780, 748, 907, 496, 142}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(746); + Tester.pruefeListenInhalt(dieListe, new int[]{746}); + + dieListe.anhaengen(941); + Tester.pruefeListenInhalt(dieListe, new int[]{746, 941}); + + dieListe.anhaengen(828); + Tester.pruefeListenInhalt(dieListe, new int[]{746, 941, 828}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{941, 828}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{828}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 590); + Tester.pruefeListenInhalt(dieListe, new int[]{590}); + + dieListe.einfuegenBei(1, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562}); + + dieListe.anhaengen(895); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895}); + + dieListe.anhaengen(165); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895, 165}); + + dieListe.einfuegenBei(4, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 895, 165, 574}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{590, 562, 165, 574}); + + dieListe.einfuegenBei(0, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574}); + + dieListe.einfuegenBei(2, 190); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 190, 562, 165, 574}); + + assertTrue("Fehler: Element 368 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(368)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574}); + + dieListe.anhaengen(624); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 562, 165, 574, 624}); + + dieListe.einfuegenBei(2, 494); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 494, 562, 165, 574, 624}); + + dieListe.anhaengen(330); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 494, 562, 165, 574, 624, 330}); + + dieListe.einfuegenBei(2, 409); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 330}); + + assertFalse("Fehler: Element 18 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(18)); + assertTrue("Fehler: Element 574 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(574)); + dieListe.einfuegenBei(8, 678); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330}); + + dieListe.anhaengen(979); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979}); + + dieListe.anhaengen(19); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 19}); + + assertFalse("Fehler: Element 380 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(380)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979}); + + dieListe.anhaengen(21); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21}); + + dieListe.anhaengen(499); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499}); + + dieListe.anhaengen(387); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499, 387}); + + dieListe.einfuegenBei(1, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 499, 387}); + + assertTrue("Fehler: Element 330 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(330)); + dieListe.einfuegenBei(13, 91); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 562, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 590, 409, 494, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 494, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387}); + + dieListe.anhaengen(967); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 499, 387, 967}); + + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{368, 42, 409, 165, 574, 624, 678, 330, 979, 21, 91, 387, 967}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(287); + Tester.pruefeListenInhalt(dieListe, new int[]{287}); + + dieListe.einfuegenBei(0, 593); + Tester.pruefeListenInhalt(dieListe, new int[]{593, 287}); + + dieListe.anhaengen(196); + Tester.pruefeListenInhalt(dieListe, new int[]{593, 287, 196}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{593, 196}); + + } + + public static void test2Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(765); + Tester.pruefeListenInhalt(dieListe, new int[]{765}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.anhaengen(575); + Tester.pruefeListenInhalt(dieListe, new int[]{765, 575}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{575}); + + dieListe.einfuegenBei(0, 273); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 575}); + + dieListe.einfuegenBei(2, 39); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 575, 39}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 39}); + + dieListe.anhaengen(989); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 39, 989}); + + assertFalse("Fehler: Element 897 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(897)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{273, 989}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{989}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{989, 23}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{23}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 792); + Tester.pruefeListenInhalt(dieListe, new int[]{792}); + + dieListe.einfuegenBei(1, 615); + Tester.pruefeListenInhalt(dieListe, new int[]{792, 615}); + + assertTrue("Fehler: Element 615 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(615)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{792}); + + assertFalse("Fehler: Element 220 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(220)); + dieListe.einfuegenBei(0, 803); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792}); + + dieListe.einfuegenBei(2, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792, 398}); + + assertFalse("Fehler: Element 986 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(986)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792}); + + dieListe.einfuegenBei(1, 42); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 42, 792}); + + assertTrue("Fehler: Element 42 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(42)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792}); + + dieListe.einfuegenBei(2, 757); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792, 757}); + + dieListe.anhaengen(35); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 792, 757, 35}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 757, 35}); + + dieListe.anhaengen(213); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 757, 35, 213}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213}); + + dieListe.anhaengen(632); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 632}); + + dieListe.einfuegenBei(3, 559); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632}); + + assertTrue("Fehler: Element 213 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(213)); + dieListe.anhaengen(141); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632, 141}); + + dieListe.anhaengen(388); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 559, 632, 141, 388}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{803, 35, 213, 632, 141, 388}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 141, 388}); + + dieListe.anhaengen(961); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 141, 388, 961}); + + assertTrue("Fehler: Element 35 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(35)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 213, 632, 388, 961}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 388, 961}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 388, 961, 349}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349}); + + dieListe.anhaengen(175); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349, 175}); + + dieListe.anhaengen(488); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 349, 175, 488}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 175, 488}); + + dieListe.anhaengen(466); + Tester.pruefeListenInhalt(dieListe, new int[]{35, 632, 961, 175, 488, 466}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 175, 488, 466}); + + dieListe.einfuegenBei(2, 689); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 689, 175, 488, 466}); + + dieListe.einfuegenBei(2, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 175, 488, 466}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466}); + + dieListe.anhaengen(119); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119}); + + assertFalse("Fehler: Element 878 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(878)); + dieListe.anhaengen(715); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.anhaengen(375); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 375}); + + dieListe.anhaengen(152); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 375, 152}); + + assertTrue("Fehler: Element 961 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(961)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 152}); + + dieListe.anhaengen(43); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 119, 715, 152, 43}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 715, 152, 43}); + + dieListe.einfuegenBei(6, 136); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 136, 715, 152, 43}); + + dieListe.einfuegenBei(6, 16); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 488, 466, 16, 136, 715, 152, 43}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 136, 715, 152, 43}); + + dieListe.einfuegenBei(6, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 956, 136, 715, 152, 43}); + + dieListe.einfuegenBei(10, 160); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 956, 136, 715, 152, 160, 43}); + + dieListe.einfuegenBei(6, 482); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 136, 715, 152, 160, 43}); + + dieListe.anhaengen(632); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 136, 715, 152, 160, 43, 632}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632}); + + dieListe.anhaengen(809); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809}); + + dieListe.anhaengen(578); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578}); + + dieListe.anhaengen(604); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578, 604}); + + dieListe.anhaengen(726); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 956, 715, 152, 160, 43, 632, 809, 578, 604, 726}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 604, 726}); + + dieListe.anhaengen(273); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 604, 726, 273}); + + dieListe.einfuegenBei(14, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 238, 604, 726, 273}); + + dieListe.einfuegenBei(18, 435); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 809, 578, 238, 604, 726, 273, 435}); + + dieListe.entferneBei(12); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 482, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435}); + + dieListe.anhaengen(359); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 359}); + + assertFalse("Fehler: Element 521 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(521)); + dieListe.anhaengen(443); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 359, 443}); + + dieListe.einfuegenBei(17, 423); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 273, 435, 423, 359, 443}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 715, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443}); + + assertTrue("Fehler: Element 632 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(632)); + dieListe.anhaengen(769); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443, 769}); + + dieListe.anhaengen(482); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 238, 604, 726, 435, 423, 359, 443, 769, 482}); + + dieListe.einfuegenBei(11, 239); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 239, 238, 604, 726, 435, 423, 359, 443, 769, 482}); + + assertTrue("Fehler: Element 769 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(769)); + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 578, 239, 238, 604, 726, 435, 359, 443, 769, 482}); + + dieListe.einfuegenBei(10, 504); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 504, 578, 239, 238, 604, 726, 435, 359, 443, 769, 482}); + + dieListe.entferneBei(16); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 504, 578, 239, 238, 604, 726, 359, 443, 769, 482}); + + assertFalse("Fehler: Element 529 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(529)); + assertTrue("Fehler: Element 466 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(466)); + assertFalse("Fehler: Element 281 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(281)); + dieListe.einfuegenBei(10, 525); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769, 482}); + + dieListe.entferneBei(20); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769}); + + dieListe.einfuegenBei(8, 301); + Tester.pruefeListenInhalt(dieListe, new int[]{632, 961, 482, 689, 466, 16, 152, 160, 301, 43, 632, 525, 504, 578, 239, 238, 604, 726, 359, 443, 769}); + + } + + public static void test3Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{397}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 67); + Tester.pruefeListenInhalt(dieListe, new int[]{67}); + + assertTrue("Fehler: Element 67 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(67)); + assertFalse("Fehler: Element 748 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(748)); + dieListe.einfuegenBei(0, 304); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67}); + + dieListe.einfuegenBei(2, 69); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69}); + + dieListe.anhaengen(577); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69, 577}); + + dieListe.anhaengen(436); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 67, 69, 577, 436}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 577, 436}); + + dieListe.anhaengen(260); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 577, 436, 260}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260}); + + dieListe.anhaengen(541); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260, 541}); + + dieListe.anhaengen(943); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 260, 541, 943}); + + assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943}); + + dieListe.anhaengen(372); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943, 372}); + + dieListe.anhaengen(846); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 541, 943, 372, 846}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 372, 846}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 372, 846, 689}); + + dieListe.einfuegenBei(4, 57); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 69, 436, 943, 57, 372, 846, 689}); + + dieListe.einfuegenBei(0, 262); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 846, 689}); + + assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689}); + + dieListe.anhaengen(129); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 129}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689}); + + dieListe.anhaengen(437); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437}); + + dieListe.anhaengen(952); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437, 952}); + + dieListe.anhaengen(807); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 689, 437, 952, 807}); + + dieListe.einfuegenBei(7, 72); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952, 807}); + + assertFalse("Fehler: Element 886 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(886)); + assertFalse("Fehler: Element 772 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(772)); + assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952}); + + dieListe.anhaengen(709); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 952, 709}); + + assertTrue("Fehler: Element 262 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(262)); + dieListe.einfuegenBei(10, 821); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 57, 372, 72, 689, 437, 821, 952, 709}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 372, 72, 689, 437, 821, 952, 709}); + + dieListe.anhaengen(898); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 372, 72, 689, 437, 821, 952, 709, 898}); + + assertTrue("Fehler: Element 72 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(72)); + dieListe.einfuegenBei(5, 139); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 69, 436, 943, 139, 372, 72, 689, 437, 821, 952, 709, 898}); + + dieListe.einfuegenBei(2, 886); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 689, 437, 821, 952, 709, 898}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 689, 821, 952, 709, 898}); + + dieListe.einfuegenBei(9, 836); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 69, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 898}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 898}); + + dieListe.entferneBei(13); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709}); + + assertTrue("Fehler: Element 943 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(943)); + assertFalse("Fehler: Element 237 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(237)); + dieListe.einfuegenBei(13, 803); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803}); + + dieListe.anhaengen(918); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 886, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803, 918}); + + assertFalse("Fehler: Element 799 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(799)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 821, 952, 709, 803, 918}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 821, 709, 803, 918}); + + assertTrue("Fehler: Element 918 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(918)); + assertFalse("Fehler: Element 652 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(652)); + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918}); + + dieListe.anhaengen(578); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578}); + + dieListe.anhaengen(954); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954}); + + dieListe.einfuegenBei(10, 961); + Tester.pruefeListenInhalt(dieListe, new int[]{262, 304, 436, 943, 139, 372, 72, 836, 689, 709, 961, 803, 918, 578, 954}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 961, 803, 918, 578, 954}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954}); + + dieListe.anhaengen(178); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178}); + + dieListe.anhaengen(733); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 139, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178, 733}); + + assertTrue("Fehler: Element 803 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(803)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 372, 72, 836, 689, 709, 803, 918, 578, 954, 178, 733}); + + assertFalse("Fehler: Element 325 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(325)); + assertFalse("Fehler: Element 50 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(50)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{304, 436, 943, 372, 72, 836, 689, 709, 803, 918, 954, 178, 733}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{467}); + + dieListe.einfuegenBei(1, 927); + Tester.pruefeListenInhalt(dieListe, new int[]{467, 927}); + + dieListe.einfuegenBei(0, 242); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 467, 927}); + + dieListe.anhaengen(474); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 467, 927, 474}); + + assertFalse("Fehler: Element 72 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(72)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 467, 927}); + + assertFalse("Fehler: Element 342 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(342)); + assertFalse("Fehler: Element 210 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(210)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{242, 927}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{242}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 111); + Tester.pruefeListenInhalt(dieListe, new int[]{111}); + + assertFalse("Fehler: Element 34 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(34)); + dieListe.einfuegenBei(1, 591); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 591}); + + dieListe.einfuegenBei(1, 308); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 308, 591}); + + dieListe.einfuegenBei(1, 819); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 819, 308, 591}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 819, 308}); + + assertTrue("Fehler: Element 819 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(819)); + dieListe.einfuegenBei(1, 225); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 225, 819, 308}); + + assertTrue("Fehler: Element 111 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(111)); + dieListe.einfuegenBei(1, 680); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 308}); + + assertTrue("Fehler: Element 680 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(680)); + dieListe.einfuegenBei(1, 686); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 686, 680, 225, 819, 308}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 308}); + + dieListe.einfuegenBei(4, 816); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 816, 308}); + + dieListe.anhaengen(124); + Tester.pruefeListenInhalt(dieListe, new int[]{111, 680, 225, 819, 816, 308, 124}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 225, 819, 816, 308, 124}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 124}); + + dieListe.einfuegenBei(4, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 19, 124}); + + dieListe.einfuegenBei(4, 569); + Tester.pruefeListenInhalt(dieListe, new int[]{680, 819, 816, 308, 569, 19, 124}); + + } + + public static void test4Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 298); + Tester.pruefeListenInhalt(dieListe, new int[]{298}); + +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(735); + Tester.pruefeListenInhalt(dieListe, new int[]{735}); + + dieListe.einfuegenBei(0, 474); + Tester.pruefeListenInhalt(dieListe, new int[]{474, 735}); + + dieListe.einfuegenBei(0, 562); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735}); + + dieListe.anhaengen(201); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735, 201}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 474, 735}); + + dieListe.einfuegenBei(0, 103); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735}); + + dieListe.anhaengen(54); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54}); + + assertTrue("Fehler: Element 735 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(735)); + assertTrue("Fehler: Element 474 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(474)); + dieListe.anhaengen(940); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54, 940}); + + assertTrue("Fehler: Element 562 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(562)); + dieListe.einfuegenBei(5, 631); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 474, 735, 54, 631, 940}); + + assertFalse("Fehler: Element 250 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(250)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940}); + + dieListe.einfuegenBei(6, 30); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 30}); + + dieListe.anhaengen(966); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 30, 966}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966}); + + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966, 931}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 631, 940, 966, 931, 748}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 562, 735, 54, 940, 966, 931, 748}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 735, 54, 940, 966, 931, 748}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 940, 966, 931, 748}); + + dieListe.einfuegenBei(5, 214); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 940, 966, 931, 214, 748}); + + dieListe.einfuegenBei(2, 28); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 931, 214, 748}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 214, 748}); + + dieListe.anhaengen(397); + Tester.pruefeListenInhalt(dieListe, new int[]{562, 54, 28, 940, 966, 214, 748, 397}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(413); + Tester.pruefeListenInhalt(dieListe, new int[]{413}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(950); + Tester.pruefeListenInhalt(dieListe, new int[]{950}); + + dieListe.einfuegenBei(0, 480); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950}); + + dieListe.anhaengen(962); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 962}); + + assertFalse("Fehler: Element 287 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(287)); + assertTrue("Fehler: Element 962 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(962)); + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 962, 581}); + + dieListe.einfuegenBei(2, 163); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 950, 163, 962, 581}); + + dieListe.einfuegenBei(1, 678); + Tester.pruefeListenInhalt(dieListe, new int[]{480, 678, 950, 163, 962, 581}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 267); + Tester.pruefeListenInhalt(dieListe, new int[]{267}); + + dieListe.einfuegenBei(1, 595); + Tester.pruefeListenInhalt(dieListe, new int[]{267, 595}); + + assertTrue("Fehler: Element 595 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(595)); + dieListe.anhaengen(812); + Tester.pruefeListenInhalt(dieListe, new int[]{267, 595, 812}); + + assertTrue("Fehler: Element 267 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(267)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{267, 812}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{267}); + + assertFalse("Fehler: Element 82 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(82)); + assertFalse("Fehler: Element 256 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(256)); + dieListe.einfuegenBei(0, 968); + Tester.pruefeListenInhalt(dieListe, new int[]{968, 267}); + + assertTrue("Fehler: Element 968 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(968)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 715); + Tester.pruefeListenInhalt(dieListe, new int[]{715}); + + dieListe.einfuegenBei(0, 56); + Tester.pruefeListenInhalt(dieListe, new int[]{56, 715}); + + dieListe.einfuegenBei(0, 332); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715}); + + dieListe.anhaengen(757); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715, 757}); + + dieListe.anhaengen(844); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715, 757, 844}); + + dieListe.einfuegenBei(1, 771); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 771, 56, 715, 757, 844}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 715, 757, 844}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 844}); + + assertTrue("Fehler: Element 332 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(332)); + assertFalse("Fehler: Element 905 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(905)); + dieListe.einfuegenBei(4, 175); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 844, 175}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175}); + + dieListe.einfuegenBei(2, 774); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 774, 757, 175}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175}); + + assertTrue("Fehler: Element 56 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(56)); + dieListe.anhaengen(711); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 175, 711}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 711}); + + dieListe.anhaengen(980); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 56, 757, 711, 980}); + + dieListe.einfuegenBei(1, 238); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 56, 757, 711, 980}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 980}); + + dieListe.anhaengen(778); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 980, 778}); + + assertTrue("Fehler: Element 980 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(980)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 778}); + + dieListe.anhaengen(241); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 778, 241}); + + dieListe.einfuegenBei(4, 142); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 757, 711, 142, 778, 241}); + + assertFalse("Fehler: Element 727 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(727)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 142, 778, 241}); + + dieListe.anhaengen(689); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 142, 778, 241, 689}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 711, 778, 241, 689}); + + assertTrue("Fehler: Element 238 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(238)); + dieListe.einfuegenBei(2, 843); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689}); + + dieListe.anhaengen(267); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689, 267}); + + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + assertFalse("Fehler: Element 925 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(925)); + dieListe.anhaengen(316); + Tester.pruefeListenInhalt(dieListe, new int[]{332, 238, 843, 711, 778, 241, 689, 267, 316}); + + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 778, 241, 689, 267, 316}); + + assertFalse("Fehler: Element 460 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(460)); + assertFalse("Fehler: Element 950 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(950)); + assertTrue("Fehler: Element 241 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(241)); + dieListe.einfuegenBei(5, 368); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 778, 241, 368, 689, 267, 316}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 711, 241, 368, 689, 267, 316}); + + assertFalse("Fehler: Element 335 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(335)); + dieListe.einfuegenBei(2, 902); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 902, 711, 241, 368, 689, 267, 316}); + + dieListe.anhaengen(905); + Tester.pruefeListenInhalt(dieListe, new int[]{238, 843, 902, 711, 241, 368, 689, 267, 316, 905}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 321); + Tester.pruefeListenInhalt(dieListe, new int[]{321}); + + } + + public static void test5Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(194); + Tester.pruefeListenInhalt(dieListe, new int[]{194}); + + dieListe.einfuegenBei(0, 694); + Tester.pruefeListenInhalt(dieListe, new int[]{694, 194}); + + assertFalse("Fehler: Element 927 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(927)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{194}); + + assertFalse("Fehler: Element 555 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(555)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(411); + Tester.pruefeListenInhalt(dieListe, new int[]{411}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 598); + Tester.pruefeListenInhalt(dieListe, new int[]{598}); + + assertFalse("Fehler: Element 360 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(360)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 413); + Tester.pruefeListenInhalt(dieListe, new int[]{413}); + + assertFalse("Fehler: Element 340 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(340)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 163); + Tester.pruefeListenInhalt(dieListe, new int[]{163}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 766); + Tester.pruefeListenInhalt(dieListe, new int[]{766}); + + assertTrue("Fehler: Element 766 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(766)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 496); + Tester.pruefeListenInhalt(dieListe, new int[]{496}); + + dieListe.anhaengen(347); + Tester.pruefeListenInhalt(dieListe, new int[]{496, 347}); + + assertFalse("Fehler: Element 196 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(196)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{347}); + + dieListe.einfuegenBei(1, 247); + Tester.pruefeListenInhalt(dieListe, new int[]{347, 247}); + + assertTrue("Fehler: Element 347 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(347)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{347}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(316); + Tester.pruefeListenInhalt(dieListe, new int[]{316}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(210); + Tester.pruefeListenInhalt(dieListe, new int[]{210}); + + assertFalse("Fehler: Element 326 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(326)); + dieListe.einfuegenBei(1, 349); + Tester.pruefeListenInhalt(dieListe, new int[]{210, 349}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{210}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(277); + Tester.pruefeListenInhalt(dieListe, new int[]{277}); + + assertTrue("Fehler: Element 277 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(277)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(594); + Tester.pruefeListenInhalt(dieListe, new int[]{594}); + + dieListe.anhaengen(154); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154}); + + dieListe.einfuegenBei(1, 586); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 586, 154}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154}); + + dieListe.einfuegenBei(1, 390); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 390, 154}); + + assertFalse("Fehler: Element 637 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(637)); + dieListe.einfuegenBei(0, 179); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 390, 154}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154}); + + dieListe.anhaengen(564); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564}); + + dieListe.einfuegenBei(4, 249); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564, 249}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{179, 594, 154, 564}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 564}); + + dieListe.einfuegenBei(2, 9); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564}); + + dieListe.anhaengen(772); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564, 772}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564}); + + dieListe.anhaengen(601); + Tester.pruefeListenInhalt(dieListe, new int[]{594, 154, 9, 564, 601}); + + assertFalse("Fehler: Element 178 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(178)); + assertTrue("Fehler: Element 594 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(594)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 601}); + + dieListe.anhaengen(438); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 601, 438}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 438}); + + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{154, 9, 564, 438, 116}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116}); + + dieListe.anhaengen(732); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732}); + + dieListe.anhaengen(748); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 748}); + + dieListe.anhaengen(412); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 748, 412}); + + assertTrue("Fehler: Element 748 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(748)); + dieListe.einfuegenBei(5, 736); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 564, 438, 116, 732, 736, 748, 412}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 438, 116, 732, 736, 748, 412}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 412}); + + assertFalse("Fehler: Element 445 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(445)); + assertFalse("Fehler: Element 52 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(52)); + dieListe.anhaengen(394); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 412, 394}); + + dieListe.einfuegenBei(5, 352); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 412, 394}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 394}); + + dieListe.anhaengen(421); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 732, 736, 748, 352, 394, 421}); + + assertFalse("Fehler: Element 179 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(179)); + assertTrue("Fehler: Element 421 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(421)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421}); + + assertFalse("Fehler: Element 629 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(629)); + dieListe.anhaengen(377); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377}); + + dieListe.anhaengen(282); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377, 282}); + + dieListe.anhaengen(735); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 748, 352, 394, 421, 377, 282, 735}); + + assertTrue("Fehler: Element 9 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(9)); + dieListe.einfuegenBei(3, 170); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 735}); + + assertTrue("Fehler: Element 116 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(116)); + dieListe.anhaengen(737); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 735, 737}); + + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737}); + + dieListe.anhaengen(78); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737, 78}); + + dieListe.anhaengen(71); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 394, 421, 377, 282, 737, 78, 71}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 421, 377, 282, 737, 78, 71}); + + dieListe.einfuegenBei(6, 369); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 737, 78, 71}); + + dieListe.einfuegenBei(10, 758); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71}); + + dieListe.anhaengen(364); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364}); + + assertFalse("Fehler: Element 275 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(275)); + dieListe.einfuegenBei(3, 727); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364}); + + dieListe.anhaengen(958); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 958}); + + dieListe.einfuegenBei(16, 555); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958}); + + dieListe.anhaengen(147); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958, 147}); + + dieListe.anhaengen(382); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 958, 147, 382}); + + dieListe.entferneBei(17); + Tester.pruefeListenInhalt(dieListe, new int[]{9, 116, 736, 727, 170, 748, 352, 369, 421, 377, 282, 758, 737, 78, 71, 364, 555, 147, 382}); + + } + + public static void test6Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(981); + Tester.pruefeListenInhalt(dieListe, new int[]{981}); + + assertFalse("Fehler: Element 802 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(802)); + dieListe.einfuegenBei(0, 672); + Tester.pruefeListenInhalt(dieListe, new int[]{672, 981}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{981}); + + dieListe.anhaengen(633); + Tester.pruefeListenInhalt(dieListe, new int[]{981, 633}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{981}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(26); + Tester.pruefeListenInhalt(dieListe, new int[]{26}); + + dieListe.einfuegenBei(1, 55); + Tester.pruefeListenInhalt(dieListe, new int[]{26, 55}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 184); + Tester.pruefeListenInhalt(dieListe, new int[]{184}); + + dieListe.einfuegenBei(0, 717); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184}); + + dieListe.einfuegenBei(2, 994); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 994}); + + assertFalse("Fehler: Element 700 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(700)); + assertFalse("Fehler: Element 574 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(574)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184}); + + dieListe.einfuegenBei(2, 641); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 641}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184}); + + dieListe.anhaengen(97); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 97}); + + dieListe.anhaengen(166); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 184, 97, 166}); + + assertFalse("Fehler: Element 178 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(178)); + dieListe.einfuegenBei(1, 362); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 97, 166}); + + assertFalse("Fehler: Element 765 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(765)); + dieListe.einfuegenBei(1, 106); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 97, 166}); + + dieListe.einfuegenBei(6, 495); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 97, 166, 495}); + + dieListe.einfuegenBei(4, 360); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 360, 97, 166, 495}); + + dieListe.einfuegenBei(4, 440); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 106, 362, 184, 440, 360, 97, 166, 495}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 440, 360, 97, 166, 495}); + + assertFalse("Fehler: Element 195 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(195)); + dieListe.einfuegenBei(2, 652); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 652, 184, 440, 360, 97, 166, 495}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 362, 184, 440, 360, 97, 166, 495}); + + dieListe.einfuegenBei(1, 824); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 184, 440, 360, 97, 166, 495}); + + assertTrue("Fehler: Element 360 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(360)); + assertFalse("Fehler: Element 315 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(315)); + assertFalse("Fehler: Element 496 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(496)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495}); + + dieListe.anhaengen(717); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495, 717}); + + dieListe.anhaengen(805); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 440, 360, 97, 166, 495, 717, 805}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 805}); + + dieListe.anhaengen(968); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 805, 968}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 166, 495, 717, 968}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 495, 717, 968}); + + dieListe.einfuegenBei(6, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 362, 360, 97, 495, 723, 717, 968}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 495, 723, 717, 968}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 495, 723, 968}); + + dieListe.einfuegenBei(2, 46); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 46, 360, 97, 495, 723, 968}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 46, 360, 97, 723, 968}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 360, 97, 723, 968}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 824, 97, 723, 968}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 97, 723, 968}); + + assertTrue("Fehler: Element 723 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(723)); + assertTrue("Fehler: Element 717 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(717)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 723, 968}); + + assertTrue("Fehler: Element 97 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(97)); + dieListe.einfuegenBei(2, 236); + Tester.pruefeListenInhalt(dieListe, new int[]{97, 723, 236, 968}); + + dieListe.einfuegenBei(0, 103); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236, 968}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236}); + + dieListe.anhaengen(990); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 97, 723, 236, 990}); + + dieListe.einfuegenBei(1, 574); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990}); + + dieListe.einfuegenBei(6, 626); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990, 626}); + + dieListe.einfuegenBei(6, 19); + Tester.pruefeListenInhalt(dieListe, new int[]{103, 574, 97, 723, 236, 990, 19, 626}); + + assertTrue("Fehler: Element 626 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(626)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(116); + Tester.pruefeListenInhalt(dieListe, new int[]{116}); + + assertFalse("Fehler: Element 306 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(306)); + dieListe.einfuegenBei(1, 512); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 512}); + + dieListe.einfuegenBei(0, 830); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 116, 512}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 512}); + + dieListe.anhaengen(455); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 512, 455}); + + dieListe.einfuegenBei(3, 682); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 512, 455, 682}); + + assertFalse("Fehler: Element 602 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(602)); + dieListe.einfuegenBei(1, 931); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 931, 512, 455, 682}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 931, 512, 682}); + + dieListe.einfuegenBei(1, 566); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 566, 931, 512, 682}); + + dieListe.anhaengen(349); + Tester.pruefeListenInhalt(dieListe, new int[]{830, 566, 931, 512, 682, 349}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 931, 512, 682, 349}); + + dieListe.einfuegenBei(3, 388); + Tester.pruefeListenInhalt(dieListe, new int[]{566, 931, 512, 388, 682, 349}); + + dieListe.einfuegenBei(0, 618); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 566, 931, 512, 388, 682, 349}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{618, 566, 931, 512, 388, 682}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 104); + Tester.pruefeListenInhalt(dieListe, new int[]{104}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 189}); + + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 189, 922}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 922}); + + assertFalse("Fehler: Element 490 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(490)); + assertFalse("Fehler: Element 507 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(507)); + dieListe.einfuegenBei(1, 910); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 922}); + + dieListe.einfuegenBei(2, 662); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662, 922}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662}); + + dieListe.einfuegenBei(1, 820); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 820, 910, 662}); + + assertTrue("Fehler: Element 910 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(910)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662}); + + dieListe.anhaengen(358); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662, 358}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 910, 662}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 662}); + + assertFalse("Fehler: Element 846 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(846)); + assertFalse("Fehler: Element 77 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(77)); + dieListe.anhaengen(473); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 662, 473}); + + dieListe.anhaengen(802); + Tester.pruefeListenInhalt(dieListe, new int[]{104, 662, 473, 802}); + + } + + public static void test7Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.einfuegenBei(0, 278); + Tester.pruefeListenInhalt(dieListe, new int[]{278}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(664); + Tester.pruefeListenInhalt(dieListe, new int[]{664}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + +// Alles löschen + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 274); + Tester.pruefeListenInhalt(dieListe, new int[]{274}); + + dieListe.einfuegenBei(1, 839); + Tester.pruefeListenInhalt(dieListe, new int[]{274, 839}); + + dieListe.einfuegenBei(1, 565); + Tester.pruefeListenInhalt(dieListe, new int[]{274, 565, 839}); + + dieListe.einfuegenBei(0, 136); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 274, 565, 839}); + + dieListe.einfuegenBei(1, 93); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 565, 839}); + + dieListe.einfuegenBei(3, 208); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 208, 565, 839}); + + dieListe.einfuegenBei(1, 320); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 320, 93, 274, 208, 565, 839}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 320, 93, 274, 208, 565}); + + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + assertTrue("Fehler: Element 320 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(320)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 93, 274, 208, 565}); + + dieListe.einfuegenBei(1, 976); + Tester.pruefeListenInhalt(dieListe, new int[]{136, 976, 93, 274, 208, 565}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(134); + Tester.pruefeListenInhalt(dieListe, new int[]{134}); + + dieListe.einfuegenBei(0, 851); + Tester.pruefeListenInhalt(dieListe, new int[]{851, 134}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{134}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(502); + Tester.pruefeListenInhalt(dieListe, new int[]{502}); + + dieListe.anhaengen(763); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 763}); + + dieListe.einfuegenBei(2, 154); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 763, 154}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154}); + + dieListe.anhaengen(38); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 38}); + + assertFalse("Fehler: Element 975 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(975)); + dieListe.anhaengen(608); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 38, 608}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 608}); + + dieListe.einfuegenBei(3, 467); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 608, 467}); + + assertFalse("Fehler: Element 715 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(715)); + assertTrue("Fehler: Element 154 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(154)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 467}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154}); + + dieListe.anhaengen(837); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 154, 837}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 837}); + + dieListe.einfuegenBei(1, 144); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 144, 837}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 144}); + + dieListe.einfuegenBei(0, 957); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 502, 144}); + + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 144}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{144}); + + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + assertTrue("Fehler: Element 144 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(144)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(216); + Tester.pruefeListenInhalt(dieListe, new int[]{216}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(754); + Tester.pruefeListenInhalt(dieListe, new int[]{754}); + + dieListe.einfuegenBei(1, 375); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375}); + + assertTrue("Fehler: Element 375 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(375)); + dieListe.anhaengen(922); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922}); + + dieListe.anhaengen(288); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288}); + + dieListe.anhaengen(18); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288, 18}); + + dieListe.anhaengen(490); + Tester.pruefeListenInhalt(dieListe, new int[]{754, 375, 922, 288, 18, 490}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 18, 490}); + + dieListe.anhaengen(841); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 18, 490, 841}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 490, 841}); + + dieListe.anhaengen(23); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 490, 841, 23}); + + dieListe.einfuegenBei(3, 595); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 841, 23}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.anhaengen(314); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 841, 23, 314}); + + dieListe.einfuegenBei(5, 674); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 922, 288, 595, 490, 674, 841, 23, 314}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + assertTrue("Fehler: Element 314 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(314)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 674, 841, 23, 314}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 841, 23, 314}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314}); + + assertFalse("Fehler: Element 107 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(107)); + dieListe.anhaengen(858); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314, 858}); + + dieListe.anhaengen(892); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 288, 595, 490, 23, 314, 858, 892}); + + dieListe.einfuegenBei(1, 539); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 490, 23, 314, 858, 892}); + + dieListe.anhaengen(875); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 490, 23, 314, 858, 892, 875}); + + dieListe.einfuegenBei(4, 64); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875}); + + dieListe.anhaengen(588); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588}); + + dieListe.einfuegenBei(12, 567); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588, 567}); + + dieListe.anhaengen(261); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 875, 588, 567, 261}); + + dieListe.einfuegenBei(10, 75); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 588, 567, 261}); + + dieListe.anhaengen(528); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 588, 567, 261, 528}); + + dieListe.einfuegenBei(12, 88); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 875, 88, 588, 567, 261, 528}); + + assertFalse("Fehler: Element 433 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(433)); + dieListe.entferneBei(11); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528}); + + dieListe.anhaengen(630); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.anhaengen(683); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683}); + + dieListe.anhaengen(211); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211}); + + assertTrue("Fehler: Element 375 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(375)); + assertTrue("Fehler: Element 588 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(588)); + assertFalse("Fehler: Element 25 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(25)); + dieListe.einfuegenBei(5, 332); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211}); + + dieListe.anhaengen(414); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 23, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 288, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414}); + + assertTrue("Fehler: Element 211 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(211)); + dieListe.anhaengen(449); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 683, 211, 414, 449}); + + dieListe.einfuegenBei(16, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 77, 683, 211, 414, 449}); + + dieListe.einfuegenBei(1, 278); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 528, 630, 77, 683, 211, 414, 449}); + + dieListe.entferneBei(15); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 630, 77, 683, 211, 414, 449}); + + dieListe.anhaengen(34); + Tester.pruefeListenInhalt(dieListe, new int[]{375, 278, 539, 595, 64, 332, 490, 314, 858, 892, 75, 88, 588, 567, 261, 630, 77, 683, 211, 414, 449, 34}); + + } + + public static void test8Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(491); + Tester.pruefeListenInhalt(dieListe, new int[]{491}); + + dieListe.einfuegenBei(1, 958); + Tester.pruefeListenInhalt(dieListe, new int[]{491, 958}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{491}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 73); + Tester.pruefeListenInhalt(dieListe, new int[]{73}); + + dieListe.anhaengen(235); + Tester.pruefeListenInhalt(dieListe, new int[]{73, 235}); + + dieListe.einfuegenBei(0, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 73, 235}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 665); + Tester.pruefeListenInhalt(dieListe, new int[]{665}); + + assertFalse("Fehler: Element 695 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(695)); +// Alles löschen + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(257); + Tester.pruefeListenInhalt(dieListe, new int[]{257}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{341}); + + dieListe.anhaengen(341); + Tester.pruefeListenInhalt(dieListe, new int[]{341, 341}); + + assertTrue("Fehler: Element 341 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(341)); +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(566); + Tester.pruefeListenInhalt(dieListe, new int[]{566}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(121); + Tester.pruefeListenInhalt(dieListe, new int[]{121}); + + dieListe.anhaengen(574); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574}); + + dieListe.anhaengen(935); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935}); + + dieListe.einfuegenBei(3, 473); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473}); + + dieListe.anhaengen(655); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 655}); + + assertTrue("Fehler: Element 655 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(655)); + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473}); + + dieListe.anhaengen(646); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646}); + + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646, 337}); + + dieListe.einfuegenBei(5, 490); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 473, 646, 490, 337}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 935, 646, 490, 337}); + + dieListe.einfuegenBei(2, 72); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 935, 646, 490, 337}); + + assertTrue("Fehler: Element 490 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(490)); + assertFalse("Fehler: Element 628 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(628)); + dieListe.anhaengen(313); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 935, 646, 490, 337, 313}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313}); + + dieListe.anhaengen(909); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313, 909}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 337, 313}); + + dieListe.einfuegenBei(5, 331); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 331, 337, 313}); + + assertFalse("Fehler: Element 485 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(485)); + dieListe.anhaengen(86); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 574, 72, 646, 490, 331, 337, 313, 86}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 72, 646, 490, 331, 337, 313, 86}); + + assertTrue("Fehler: Element 121 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(121)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 490, 331, 337, 313, 86}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 337, 313, 86}); + + dieListe.anhaengen(600); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 337, 313, 86, 600}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{121, 646, 331, 313, 86, 600}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 437); + Tester.pruefeListenInhalt(dieListe, new int[]{437}); + + assertFalse("Fehler: Element 412 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(412)); + dieListe.anhaengen(788); + Tester.pruefeListenInhalt(dieListe, new int[]{437, 788}); + + assertFalse("Fehler: Element 304 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(304)); + dieListe.anhaengen(286); + Tester.pruefeListenInhalt(dieListe, new int[]{437, 788, 286}); + + assertFalse("Fehler: Element 526 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(526)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{788, 286}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{286}); + + dieListe.anhaengen(618); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618}); + + dieListe.anhaengen(352); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352}); + + assertFalse("Fehler: Element 237 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(237)); + dieListe.anhaengen(581); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 581}); + + dieListe.anhaengen(931); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 581, 931}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 618, 352, 931}); + + assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618)); + dieListe.einfuegenBei(1, 861); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 861, 618, 352, 931}); + + assertTrue("Fehler: Element 931 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(931)); + dieListe.einfuegenBei(3, 190); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 861, 618, 190, 352, 931}); + + assertTrue("Fehler: Element 861 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(861)); + assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618)); + dieListe.einfuegenBei(1, 699); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 699, 861, 618, 190, 352, 931}); + + dieListe.einfuegenBei(2, 935); + Tester.pruefeListenInhalt(dieListe, new int[]{286, 699, 935, 861, 618, 190, 352, 931}); + + dieListe.einfuegenBei(0, 653); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 190, 352, 931}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931}); + + assertTrue("Fehler: Element 286 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(286)); + assertFalse("Fehler: Element 781 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(781)); + dieListe.einfuegenBei(8, 959); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931, 959}); + + dieListe.anhaengen(337); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 699, 935, 861, 618, 352, 931, 959, 337}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 931, 959, 337}); + + dieListe.einfuegenBei(4, 698); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337}); + + dieListe.anhaengen(333); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333}); + + assertFalse("Fehler: Element 180 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(180)); + assertFalse("Fehler: Element 702 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(702)); + assertFalse("Fehler: Element 226 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(226)); + dieListe.anhaengen(623); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623}); + + assertFalse("Fehler: Element 939 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(939)); + dieListe.anhaengen(25); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623, 25}); + + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + dieListe.anhaengen(595); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 931, 959, 337, 333, 623, 25, 595}); + + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595}); + + dieListe.anhaengen(494); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595, 494}); + + assertTrue("Fehler: Element 618 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(618)); + dieListe.anhaengen(440); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 698, 618, 352, 959, 337, 333, 623, 25, 595, 494, 440}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 959, 337, 333, 623, 25, 595, 494, 440}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440}); + + assertTrue("Fehler: Element 337 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(337)); + dieListe.anhaengen(838); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 286, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{653, 935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838}); + + assertFalse("Fehler: Element 421 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(421)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{935, 861, 618, 352, 337, 333, 623, 25, 595, 494, 440, 838}); + + assertFalse("Fehler: Element 153 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(153)); + assertTrue("Fehler: Element 623 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(623)); + } + + public static void test9Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(202); + Tester.pruefeListenInhalt(dieListe, new int[]{202}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 422); + Tester.pruefeListenInhalt(dieListe, new int[]{422}); + + assertFalse("Fehler: Element 558 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(558)); + assertTrue("Fehler: Element 422 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(422)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(707); + Tester.pruefeListenInhalt(dieListe, new int[]{707}); + + dieListe.einfuegenBei(1, 942); + Tester.pruefeListenInhalt(dieListe, new int[]{707, 942}); + + dieListe.einfuegenBei(0, 116); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 942}); + + dieListe.einfuegenBei(3, 536); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 942, 536}); + + assertTrue("Fehler: Element 942 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(942)); + dieListe.einfuegenBei(2, 339); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339, 942, 536}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339, 536}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707, 339}); + + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{116, 707}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{116}); + + assertFalse("Fehler: Element 465 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(465)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 134); + Tester.pruefeListenInhalt(dieListe, new int[]{134}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(336); + Tester.pruefeListenInhalt(dieListe, new int[]{336}); + + dieListe.anhaengen(417); + Tester.pruefeListenInhalt(dieListe, new int[]{336, 417}); + + dieListe.anhaengen(592); + Tester.pruefeListenInhalt(dieListe, new int[]{336, 417, 592}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{417, 592}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{592}); + + dieListe.einfuegenBei(0, 901); + Tester.pruefeListenInhalt(dieListe, new int[]{901, 592}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{592}); + + assertFalse("Fehler: Element 351 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(351)); + assertTrue("Fehler: Element 592 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(592)); + assertFalse("Fehler: Element 169 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(169)); + dieListe.einfuegenBei(1, 634); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 634}); + + assertTrue("Fehler: Element 592 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(592)); + dieListe.einfuegenBei(2, 862); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 634, 862}); + + assertFalse("Fehler: Element 574 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(574)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 634}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{592}); + + dieListe.anhaengen(866); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 866}); + + dieListe.anhaengen(785); + Tester.pruefeListenInhalt(dieListe, new int[]{592, 866, 785}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 785}); + + dieListe.einfuegenBei(0, 427); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785}); + + dieListe.anhaengen(189); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785, 189}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{427, 866, 785}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 785}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{866}); + + dieListe.anhaengen(923); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 923}); + + dieListe.einfuegenBei(1, 904); + Tester.pruefeListenInhalt(dieListe, new int[]{866, 904, 923}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923}); + + dieListe.einfuegenBei(2, 884); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923, 884}); + + dieListe.anhaengen(778); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923, 884, 778}); + + assertTrue("Fehler: Element 778 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(778)); + assertFalse("Fehler: Element 394 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(394)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 923, 884}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{904, 884}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{904}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 956); + Tester.pruefeListenInhalt(dieListe, new int[]{956}); + + assertTrue("Fehler: Element 956 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(956)); + dieListe.einfuegenBei(1, 140); + Tester.pruefeListenInhalt(dieListe, new int[]{956, 140}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{140}); + + assertFalse("Fehler: Element 797 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(797)); + dieListe.einfuegenBei(1, 174); + Tester.pruefeListenInhalt(dieListe, new int[]{140, 174}); + + dieListe.anhaengen(893); + Tester.pruefeListenInhalt(dieListe, new int[]{140, 174, 893}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 893}); + + dieListe.anhaengen(892); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 893, 892}); + + dieListe.einfuegenBei(3, 769); + Tester.pruefeListenInhalt(dieListe, new int[]{174, 893, 892, 769}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 892, 769}); + + assertFalse("Fehler: Element 429 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(429)); + dieListe.anhaengen(193); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 892, 769, 193}); + + dieListe.anhaengen(676); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 892, 769, 193, 676}); + + dieListe.einfuegenBei(0, 723); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 893, 892, 769, 193, 676}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 893, 892, 769, 676}); + + dieListe.einfuegenBei(1, 481); + Tester.pruefeListenInhalt(dieListe, new int[]{723, 481, 893, 892, 769, 676}); + + assertTrue("Fehler: Element 481 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(481)); + assertTrue("Fehler: Element 892 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(892)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 769, 676}); + + dieListe.einfuegenBei(3, 637); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 676}); + + assertFalse("Fehler: Element 870 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(870)); + dieListe.anhaengen(477); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 676, 477}); + + dieListe.einfuegenBei(5, 59); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 893, 892, 637, 769, 59, 676, 477}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{481, 892, 637, 769, 59, 676, 477}); + + assertTrue("Fehler: Element 676 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(676)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 769, 59, 676, 477}); + + dieListe.einfuegenBei(2, 540); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 769, 59, 676, 477}); + + assertFalse("Fehler: Element 861 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(861)); + dieListe.einfuegenBei(7, 857); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 769, 59, 676, 477, 857}); + + dieListe.einfuegenBei(3, 674); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 59, 676, 477, 857}); + + assertTrue("Fehler: Element 59 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(59)); + dieListe.einfuegenBei(5, 382); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 477, 857}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 477}); + + assertTrue("Fehler: Element 674 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(674)); + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676}); + + dieListe.einfuegenBei(3, 921); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 921, 674, 769, 382, 59, 676}); + + assertTrue("Fehler: Element 637 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(637)); + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676}); + + dieListe.einfuegenBei(8, 77); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77}); + + assertTrue("Fehler: Element 769 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(769)); + dieListe.anhaengen(791); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 791}); + + dieListe.einfuegenBei(10, 702); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 791, 702}); + + assertFalse("Fehler: Element 553 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(553)); + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{892, 637, 540, 674, 769, 382, 59, 676, 77, 702}); + + } + + public static void test10Durchfuehren(Liste dieListe) { + assertTrue(dieListe.istLeer()); + dieListe.anhaengen(957); + Tester.pruefeListenInhalt(dieListe, new int[]{957}); + + dieListe.anhaengen(306); + Tester.pruefeListenInhalt(dieListe, new int[]{957, 306}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{306}); + + dieListe.anhaengen(72); + Tester.pruefeListenInhalt(dieListe, new int[]{306, 72}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{306}); + + assertFalse("Fehler: Element 550 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(550)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 149); + Tester.pruefeListenInhalt(dieListe, new int[]{149}); + + dieListe.anhaengen(61); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61}); + + dieListe.anhaengen(671); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671}); + + assertTrue("Fehler: Element 61 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(61)); + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + dieListe.anhaengen(674); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671, 674}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671}); + + dieListe.anhaengen(510); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 61, 671, 510}); + + dieListe.einfuegenBei(1, 519); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 671, 510}); + + dieListe.anhaengen(460); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 671, 510, 460}); + + assertTrue("Fehler: Element 149 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(149)); + dieListe.einfuegenBei(3, 676); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 676, 671, 510, 460}); + + dieListe.einfuegenBei(3, 717); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 510, 460}); + + dieListe.einfuegenBei(6, 941); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460}); + + assertFalse("Fehler: Element 836 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(836)); + dieListe.anhaengen(470); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470}); + + dieListe.anhaengen(852); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470, 852}); + + assertFalse("Fehler: Element 894 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(894)); + dieListe.entferneBei(10); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 676, 671, 941, 510, 460, 470}); + + dieListe.einfuegenBei(4, 126); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 671, 941, 510, 460, 470}); + + dieListe.einfuegenBei(7, 396); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 671, 396, 941, 510, 460, 470}); + + dieListe.entferneBei(6); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 470}); + + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 470, 659}); + + assertFalse("Fehler: Element 588 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(588)); + dieListe.einfuegenBei(10, 398); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 398, 470, 659}); + + assertTrue("Fehler: Element 398 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(398)); + dieListe.einfuegenBei(12, 366); + Tester.pruefeListenInhalt(dieListe, new int[]{149, 519, 61, 717, 126, 676, 396, 941, 510, 460, 398, 470, 366, 659}); + +// Alles löschen + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + dieListe.entferneBei(0); + assertTrue(dieListe.istLeer()); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(795); + Tester.pruefeListenInhalt(dieListe, new int[]{795}); + + assertTrue("Fehler: Element 795 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(795)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.anhaengen(526); + Tester.pruefeListenInhalt(dieListe, new int[]{526}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 661); + Tester.pruefeListenInhalt(dieListe, new int[]{661}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{}); + + dieListe.einfuegenBei(0, 893); + Tester.pruefeListenInhalt(dieListe, new int[]{893}); + + dieListe.einfuegenBei(0, 502); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893}); + + dieListe.anhaengen(854); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854}); + + dieListe.anhaengen(99); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99}); + + dieListe.anhaengen(808); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 808}); + + dieListe.einfuegenBei(5, 21); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 808, 21}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 854, 99, 21}); + + dieListe.einfuegenBei(2, 211); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854, 99, 21}); + + dieListe.entferneBei(5); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854, 99}); + + dieListe.entferneBei(4); + Tester.pruefeListenInhalt(dieListe, new int[]{502, 893, 211, 854}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{893, 211, 854}); + + assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854)); + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{211, 854}); + + dieListe.einfuegenBei(2, 922); + Tester.pruefeListenInhalt(dieListe, new int[]{211, 854, 922}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{854, 922}); + + assertFalse("Fehler: Element 386 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(386)); + dieListe.einfuegenBei(0, 831); + Tester.pruefeListenInhalt(dieListe, new int[]{831, 854, 922}); + + dieListe.einfuegenBei(1, 252); + Tester.pruefeListenInhalt(dieListe, new int[]{831, 252, 854, 922}); + + dieListe.einfuegenBei(0, 370); + Tester.pruefeListenInhalt(dieListe, new int[]{370, 831, 252, 854, 922}); + + assertFalse("Fehler: Element 492 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(492)); + assertTrue("Fehler: Element 831 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(831)); + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{370, 252, 854, 922}); + + assertFalse("Fehler: Element 718 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(718)); + dieListe.anhaengen(395); + Tester.pruefeListenInhalt(dieListe, new int[]{370, 252, 854, 922, 395}); + + dieListe.entferneBei(0); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395}); + + dieListe.einfuegenBei(4, 207); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207}); + + dieListe.anhaengen(974); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974}); + + dieListe.anhaengen(290); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290}); + + dieListe.einfuegenBei(3, 915); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290}); + + dieListe.einfuegenBei(7, 784); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 784, 290}); + + assertFalse("Fehler: Element 870 gefunden, sollte nicht gefunden werden.", dieListe.enthaelt(870)); + assertTrue("Fehler: Element 290 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(290)); + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 784, 290, 708}); + + assertTrue("Fehler: Element 854 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(854)); + dieListe.entferneBei(7); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290, 708}); + + dieListe.entferneBei(8); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 915, 395, 207, 974, 290}); + + dieListe.entferneBei(3); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290}); + + dieListe.anhaengen(722); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290, 722}); + + dieListe.anhaengen(663); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 854, 922, 395, 207, 974, 290, 722, 663}); + + dieListe.entferneBei(1); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 722, 663}); + + dieListe.anhaengen(746); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 722, 663, 746}); + + dieListe.einfuegenBei(6, 377); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746}); + + assertTrue("Fehler: Element 974 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(974)); + dieListe.anhaengen(271); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271}); + + dieListe.anhaengen(708); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271, 708}); + + assertTrue("Fehler: Element 271 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(271)); + dieListe.einfuegenBei(11, 974); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 663, 746, 271, 974, 708}); + + dieListe.einfuegenBei(8, 426); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 395, 207, 974, 290, 377, 722, 426, 663, 746, 271, 974, 708}); + + assertTrue("Fehler: Element 395 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(395)); + dieListe.entferneBei(2); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 746, 271, 974, 708}); + + dieListe.entferneBei(9); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 271, 974, 708}); + + dieListe.einfuegenBei(9, 132); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708}); + + dieListe.einfuegenBei(13, 666); + Tester.pruefeListenInhalt(dieListe, new int[]{252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666}); + + assertTrue("Fehler: Element 252 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(252)); + dieListe.einfuegenBei(0, 717); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666}); + + assertTrue("Fehler: Element 426 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(426)); + assertTrue("Fehler: Element 974 nicht gefunden, sollte gefunden werden.", dieListe.enthaelt(974)); + dieListe.anhaengen(659); + Tester.pruefeListenInhalt(dieListe, new int[]{717, 252, 922, 207, 974, 290, 377, 722, 426, 663, 132, 271, 974, 708, 666, 659}); + + } +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/Tester.java b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/Tester.java new file mode 100644 index 0000000..eeebb1f --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/Tester.java @@ -0,0 +1,530 @@ +package tests; + +import liste.*; +import tests.*; + +import static org.junit.Assert.*; + +import org.junit.Test; + +/** + * Die Test-Klasse Tester. + * + * @author Rainer Helfrich + * @version 03.10.2020 + */ +public abstract class Tester { + protected Liste dieListe; + + protected static void pruefeListenInhalt(Liste dieListe, int[] erwartet) { + if (erwartet.length == 0) + assertTrue(dieListe.istLeer()); + else + assertFalse(dieListe.istLeer()); + assertEquals("Fehler: Länge stimmt nicht.", erwartet.length, dieListe.laenge()); + for (int i = 0; i < erwartet.length; i++) { + assertEquals("Fehler: Element an Index " + i + " stimmt nicht.", erwartet[i], dieListe.getNtenWert(i).intValue()); + } + } + + @Test + public void test001() { + SubTest1.test1Durchfuehren(dieListe); + } + + @Test + public void test002() { + SubTest1.test2Durchfuehren(dieListe); + } + + @Test + public void test003() { + SubTest1.test3Durchfuehren(dieListe); + } + + @Test + public void test004() { + SubTest1.test4Durchfuehren(dieListe); + } + + @Test + public void test005() { + SubTest1.test5Durchfuehren(dieListe); + } + + @Test + public void test006() { + SubTest1.test6Durchfuehren(dieListe); + } + + @Test + public void test007() { + SubTest1.test7Durchfuehren(dieListe); + } + + @Test + public void test008() { + SubTest1.test8Durchfuehren(dieListe); + } + + @Test + public void test009() { + SubTest1.test9Durchfuehren(dieListe); + } + + @Test + public void test010() { + SubTest1.test10Durchfuehren(dieListe); + } + + @Test + public void test011() { + SubTest2.test1Durchfuehren(dieListe); + } + + @Test + public void test012() { + SubTest2.test2Durchfuehren(dieListe); + } + + @Test + public void test013() { + SubTest2.test3Durchfuehren(dieListe); + } + + @Test + public void test014() { + SubTest2.test4Durchfuehren(dieListe); + } + + @Test + public void test015() { + SubTest2.test5Durchfuehren(dieListe); + } + + @Test + public void test016() { + SubTest2.test6Durchfuehren(dieListe); + } + + @Test + public void test017() { + SubTest2.test7Durchfuehren(dieListe); + } + + @Test + public void test018() { + SubTest2.test8Durchfuehren(dieListe); + } + + @Test + public void test019() { + SubTest2.test9Durchfuehren(dieListe); + } + + @Test + public void test020() { + SubTest2.test10Durchfuehren(dieListe); + } + + @Test + public void test021() { + SubTest3.test1Durchfuehren(dieListe); + } + + @Test + public void test022() { + SubTest3.test2Durchfuehren(dieListe); + } + + @Test + public void test023() { + SubTest3.test3Durchfuehren(dieListe); + } + + @Test + public void test024() { + SubTest3.test4Durchfuehren(dieListe); + } + + @Test + public void test025() { + SubTest3.test5Durchfuehren(dieListe); + } + + @Test + public void test026() { + SubTest3.test6Durchfuehren(dieListe); + } + + @Test + public void test027() { + SubTest3.test7Durchfuehren(dieListe); + } + + @Test + public void test028() { + SubTest3.test8Durchfuehren(dieListe); + } + + @Test + public void test029() { + SubTest3.test9Durchfuehren(dieListe); + } + + @Test + public void test030() { + SubTest3.test10Durchfuehren(dieListe); + } + + @Test + public void test031() { + SubTest4.test1Durchfuehren(dieListe); + } + + @Test + public void test032() { + SubTest4.test2Durchfuehren(dieListe); + } + + @Test + public void test033() { + SubTest4.test3Durchfuehren(dieListe); + } + + @Test + public void test034() { + SubTest4.test4Durchfuehren(dieListe); + } + + @Test + public void test035() { + SubTest4.test5Durchfuehren(dieListe); + } + + @Test + public void test036() { + SubTest4.test6Durchfuehren(dieListe); + } + + @Test + public void test037() { + SubTest4.test7Durchfuehren(dieListe); + } + + @Test + public void test038() { + SubTest4.test8Durchfuehren(dieListe); + } + + @Test + public void test039() { + SubTest4.test9Durchfuehren(dieListe); + } + + @Test + public void test040() { + SubTest4.test10Durchfuehren(dieListe); + } + + @Test + public void test041() { + SubTest5.test1Durchfuehren(dieListe); + } + + @Test + public void test042() { + SubTest5.test2Durchfuehren(dieListe); + } + + @Test + public void test043() { + SubTest5.test3Durchfuehren(dieListe); + } + + @Test + public void test044() { + SubTest5.test4Durchfuehren(dieListe); + } + + @Test + public void test045() { + SubTest5.test5Durchfuehren(dieListe); + } + + @Test + public void test046() { + SubTest5.test6Durchfuehren(dieListe); + } + + @Test + public void test047() { + SubTest5.test7Durchfuehren(dieListe); + } + + @Test + public void test048() { + SubTest5.test8Durchfuehren(dieListe); + } + + @Test + public void test049() { + SubTest5.test9Durchfuehren(dieListe); + } + + @Test + public void test050() { + SubTest5.test10Durchfuehren(dieListe); + } + + @Test + public void test051() { + SubTest6.test1Durchfuehren(dieListe); + } + + @Test + public void test052() { + SubTest6.test2Durchfuehren(dieListe); + } + + @Test + public void test053() { + SubTest6.test3Durchfuehren(dieListe); + } + + @Test + public void test054() { + SubTest6.test4Durchfuehren(dieListe); + } + + @Test + public void test055() { + SubTest6.test5Durchfuehren(dieListe); + } + + @Test + public void test056() { + SubTest6.test6Durchfuehren(dieListe); + } + + @Test + public void test057() { + SubTest6.test7Durchfuehren(dieListe); + } + + @Test + public void test058() { + SubTest6.test8Durchfuehren(dieListe); + } + + @Test + public void test059() { + SubTest6.test9Durchfuehren(dieListe); + } + + @Test + public void test060() { + SubTest6.test10Durchfuehren(dieListe); + } + + @Test + public void test061() { + SubTest7.test1Durchfuehren(dieListe); + } + + @Test + public void test062() { + SubTest7.test2Durchfuehren(dieListe); + } + + @Test + public void test063() { + SubTest7.test3Durchfuehren(dieListe); + } + + @Test + public void test064() { + SubTest7.test4Durchfuehren(dieListe); + } + + @Test + public void test065() { + SubTest7.test5Durchfuehren(dieListe); + } + + @Test + public void test066() { + SubTest7.test6Durchfuehren(dieListe); + } + + @Test + public void test067() { + SubTest7.test7Durchfuehren(dieListe); + } + + @Test + public void test068() { + SubTest7.test8Durchfuehren(dieListe); + } + + @Test + public void test069() { + SubTest7.test9Durchfuehren(dieListe); + } + + @Test + public void test070() { + SubTest7.test10Durchfuehren(dieListe); + } + + @Test + public void test071() { + SubTest8.test1Durchfuehren(dieListe); + } + + @Test + public void test072() { + SubTest8.test2Durchfuehren(dieListe); + } + + @Test + public void test073() { + SubTest8.test3Durchfuehren(dieListe); + } + + @Test + public void test074() { + SubTest8.test4Durchfuehren(dieListe); + } + + @Test + public void test075() { + SubTest8.test5Durchfuehren(dieListe); + } + + @Test + public void test076() { + SubTest8.test6Durchfuehren(dieListe); + } + + @Test + public void test077() { + SubTest8.test7Durchfuehren(dieListe); + } + + @Test + public void test078() { + SubTest8.test8Durchfuehren(dieListe); + } + + @Test + public void test079() { + SubTest8.test9Durchfuehren(dieListe); + } + + @Test + public void test080() { + SubTest8.test10Durchfuehren(dieListe); + } + + @Test + public void test081() { + SubTest9.test1Durchfuehren(dieListe); + } + + @Test + public void test082() { + SubTest9.test2Durchfuehren(dieListe); + } + + @Test + public void test083() { + SubTest9.test3Durchfuehren(dieListe); + } + + @Test + public void test084() { + SubTest9.test4Durchfuehren(dieListe); + } + + @Test + public void test085() { + SubTest9.test5Durchfuehren(dieListe); + } + + @Test + public void test086() { + SubTest9.test6Durchfuehren(dieListe); + } + + @Test + public void test087() { + SubTest9.test7Durchfuehren(dieListe); + } + + @Test + public void test088() { + SubTest9.test8Durchfuehren(dieListe); + } + + @Test + public void test089() { + SubTest9.test9Durchfuehren(dieListe); + } + + @Test + public void test090() { + SubTest9.test10Durchfuehren(dieListe); + } + + @Test + public void test091() { + SubTest10.test1Durchfuehren(dieListe); + } + + @Test + public void test092() { + SubTest10.test2Durchfuehren(dieListe); + } + + @Test + public void test093() { + SubTest10.test3Durchfuehren(dieListe); + } + + @Test + public void test094() { + SubTest10.test4Durchfuehren(dieListe); + } + + @Test + public void test095() { + SubTest10.test5Durchfuehren(dieListe); + } + + @Test + public void test096() { + SubTest10.test6Durchfuehren(dieListe); + } + + @Test + public void test097() { + SubTest10.test7Durchfuehren(dieListe); + } + + @Test + public void test098() { + SubTest10.test8Durchfuehren(dieListe); + } + + @Test + public void test099() { + SubTest10.test9Durchfuehren(dieListe); + } + + @Test + public void test100() { + SubTest10.test10Durchfuehren(dieListe); + } + +} diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/package.bluej b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/package.bluej new file mode 100644 index 0000000..1e8df5a --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/02_verkettete_liste_loes/tests/package.bluej @@ -0,0 +1,157 @@ +#BlueJ package file +dependency1.from=SubTest6 +dependency1.to=Tester +dependency1.type=UsesDependency +dependency10.from=SubTest1 +dependency10.to=Tester +dependency10.type=UsesDependency +dependency11.from=Tester +dependency11.to=SubTest1 +dependency11.type=UsesDependency +dependency12.from=Tester +dependency12.to=SubTest2 +dependency12.type=UsesDependency +dependency13.from=Tester +dependency13.to=SubTest3 +dependency13.type=UsesDependency +dependency14.from=Tester +dependency14.to=SubTest4 +dependency14.type=UsesDependency +dependency15.from=Tester +dependency15.to=SubTest5 +dependency15.type=UsesDependency +dependency16.from=Tester +dependency16.to=SubTest6 +dependency16.type=UsesDependency +dependency17.from=Tester +dependency17.to=SubTest7 +dependency17.type=UsesDependency +dependency18.from=Tester +dependency18.to=SubTest8 +dependency18.type=UsesDependency +dependency19.from=Tester +dependency19.to=SubTest9 +dependency19.type=UsesDependency +dependency2.from=SubTest7 +dependency2.to=Tester +dependency2.type=UsesDependency +dependency20.from=Tester +dependency20.to=SubTest10 +dependency20.type=UsesDependency +dependency3.from=SubTest8 +dependency3.to=Tester +dependency3.type=UsesDependency +dependency4.from=SubTest9 +dependency4.to=Tester +dependency4.type=UsesDependency +dependency5.from=SubTest2 +dependency5.to=Tester +dependency5.type=UsesDependency +dependency6.from=SubTest3 +dependency6.to=Tester +dependency6.type=UsesDependency +dependency7.from=SubTest4 +dependency7.to=Tester +dependency7.type=UsesDependency +dependency8.from=SubTest5 +dependency8.to=Tester +dependency8.type=UsesDependency +dependency9.from=SubTest10 +dependency9.to=Tester +dependency9.type=UsesDependency +objectbench.height=97 +objectbench.width=1004 +package.divider.horizontal=0.5922619047619048 +package.divider.vertical=0.8488372093023255 +package.editor.height=577 +package.editor.width=893 +package.editor.x=0 +package.editor.y=43 +package.frame.height=788 +package.frame.width=1044 +package.numDependencies=20 +package.numTargets=11 +package.showExtends=true +package.showUses=true +readme.height=58 +readme.name=@README +readme.width=47 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=SubTest6 +target1.showInterface=false +target1.type=ClassTarget +target1.width=80 +target1.x=330 +target1.y=340 +target10.height=50 +target10.name=SubTest10 +target10.showInterface=false +target10.type=ClassTarget +target10.width=90 +target10.x=690 +target10.y=340 +target11.height=50 +target11.name=SubTest1 +target11.showInterface=false +target11.type=ClassTarget +target11.width=80 +target11.x=330 +target11.y=280 +target2.height=50 +target2.name=SubTest7 +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=420 +target2.y=340 +target3.height=50 +target3.name=SubTest8 +target3.showInterface=false +target3.type=ClassTarget +target3.width=80 +target3.x=510 +target3.y=340 +target4.height=50 +target4.name=SubTest9 +target4.showInterface=false +target4.type=ClassTarget +target4.width=80 +target4.x=600 +target4.y=340 +target5.height=50 +target5.name=Tester +target5.showInterface=false +target5.type=AbstractTarget +target5.width=80 +target5.x=510 +target5.y=150 +target6.height=50 +target6.name=SubTest2 +target6.showInterface=false +target6.type=ClassTarget +target6.width=80 +target6.x=420 +target6.y=280 +target7.height=50 +target7.name=SubTest3 +target7.showInterface=false +target7.type=ClassTarget +target7.width=80 +target7.x=510 +target7.y=280 +target8.height=50 +target8.name=SubTest4 +target8.showInterface=false +target8.type=ClassTarget +target8.width=80 +target8.x=600 +target8.y=280 +target9.height=50 +target9.name=SubTest5 +target9.showInterface=false +target9.type=ClassTarget +target9.width=80 +target9.x=690 +target9.y=280 diff --git a/Quellcodes/Alg_DS_Verkettete_Liste/readme.adoc b/Quellcodes/Alg_DS_Verkettete_Liste/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_DS_Verkettete_Liste/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt